Tcl, 150 bytes

proc R {s n\ 19} {string repe $s $n}
puts " [R _]
/[R \ ]\\
-[R -]- 
[set T |[R \ ]|\n-[R -]- ]
$T
\\[R _ 11]    ____/
[set S [R \  12]|]  /
$S /
$S/"

Try it online!

Another version with same number of bytes:

Tcl, 150 bytes

proc R {s n\ 19} {string repe $s $n}
puts " [R _]
/[R \ ]\\
[set T -[R -]-\ \n|[R \ ]|]
$T
-[R -]-
\\[R _ 11]    ____/
[set S [R \  12]|]  /
$S /
$S/"

Try it online!

AWK, 189 bytes

func p(x,y){for(t=X;y--;)t=t x;return t}END{a=p("-",22)"\n";b="|"p(" ",20)"|\n";c=p(" ",11);print " "p("_",20)"\n/"p(" ",20)"\\\n"a b a b a"\\"p("_",11)"   ______/\n"c"|  /\n"c"| /\n"c"|/"}

Try it online!

Colorful Version

END{print"\033[38;5;75m🭅🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🭐\n\033[38;5;39m🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆\n\033[38;5;25m🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆🮆\n\033[38;5;17m🭖▇▇▇▇▇▇▇▇▇▇▇🭡\n 🭚"}

Looks best in your terminal with a monospace font.

Perl 5, 121 bytes

say for$".'_'x19 .$",$_='/'.$"x19 ."\\",($b=y//-/cr,y/ /|/cr)x2,$b,'\\__________    _____/',map$"x11 .'|'.$"x$_.'/',2,1,0

Try it online!

Japt, 79 72 71 67 bytes

" j_
/j \\
{"l-
|j |
"²}l-
\\a_4 5_/
b |  /
b | /
b |/"r"%w."ÈÌpXnH

Test it

7 bytes saved thanks to ETHproductions' excellent suggestion of using base 32 integers for the repetition values.

"...{"..."²}..."r"%w."ÈÌpXnH
"...                             :Start of literal string
    {                            :  Interpolate
     "..."                       :    Literal string
          ²                      :    Duplicate
           }                     :  End Interpolate
            ..."                 :End of literal string
                r                :Replace
                 "%w."           :  RegEx /[a-z0-9]./g
                      È          :  Pass each match through the following function as X
                       Ì         :    Last character
                        p        :    Repeat
                         Xn      :      Convert X to decimal from base
                           H     :       32 (parsing halts when it encounters an unexpected digit)

PowerShell, 116 115 bytes

' _19
/ 19\
-21
| 19|
-21
| 19|
-21
\_10 4_5/
 11|  /
 11| /
 11|/'-replace'(.)(\d+)',{$x,$c,$n=$_|% gr*;"$c"*"$n"}

Try it online!

Windows batch, 263 bytes

@echo off
echo  ___________________
echo /                   \
for /l %%G in (1,1,2)do (
echo ---------------------
echo ^|                   ^|
)
echo ---------------------
echo \__________    _____/
echo            ^|  /
echo            ^| /
echo            ^|/

R16K1S60 Assembly, 152 144 Bytes

Writes output to screen peripheral the R16K1S60 in ASCII. Runs on The Powder Toy save 2012356. (See link in header for info)

The byte size of the program is the compiled result (Cells Used * 2), not the assembly.

You know you've done well when the logo takes more space than your bytecode.

a:
mov ex, ip
mov ax, .string
mov sp, ip
mov dx, 0x1000
send sp, dx
.loop:
mov bx, [ax]
cmp bx, ip
je .end
cmp bx, ip
je .newline

shr bx, cx, 8
and cx, 0x00FF
.inner:
send sp, cx
sub bx, ex
jnz .inner
.reentry:
add ax, ex
jmp .loop
.newline:
add dx, 0x0020
send sp, dx
jmp .reentry
.string:
dw 0x0120
dw 0x135F
dw 0x000C
dw 0x012F
dw 0x1320
dw 0x015C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x017C
dw 0x1320
dw 0x017C
dw 0x000C
dw 0x152D
dw 0x000C
dw 0x015C
dw 0x0A5F
dw 0x0420
dw 0x055F
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0220
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x0120
dw 0x012F
dw 0x000C
dw 0x0B20
dw 0x017C
dw 0x012F
dw 0x0009
.end:
hlt

Explanation

The assembly code above implements a simple compression algorithm, with the words 0x000C being a newline and 0x0009 being the command to stop execution.

The other words are encoded simply, like this: 0xTTCC

• T: Times to repeat the value

• C: The ASCII character to print

The ASM uses every register available to it, including some of the less commonly used ones:

• The Instruction Pointer, to get a few known values into quick recall to save some bytes (A constant value in an instuction that's not just a register uses an extra byte to store it)

• The Stack Pointer is used as 6th general purpose register, because none of the code uses the stack.

Only AX, BX, CX, and DX are actually used for important data. EX and SP are used to store some constants that get frequently used.

It's somewhat simple, and has nil chance of winning, but it was fun to write!

See revision history for the old answer (It's just as large in terms of ASM)

funfact: if this was measured in words (in the case of the R16K1S60,16 bits) it'd be smaller than the pyth answer, at 72 bytes

Pyth, 74 bytes

J*21\-L*db+d*19\_++\/y19\\V2J++\|y19\|;J++++\\*T\_y4*5\_\/V3+++y11\|y-2N\/

Try it online!

C (gcc), 138 137 bytes

That string still taunts me with its look of compressibility.

f(i){for(char*s=" S_:/S \\:U-:|S |:U-:|S |:U-:\\J_D E_/:K |  /:K | /:K |/";*s;s++)for(i=*s>64&*s<91?*s++-64:1;i--;)putchar(*s^58?*s:10);}

Try it online!

Golfscript, 102 bytes

Try it online!

This is less than half the size of the actual output.

' ''_'9*.'_ 
/'' '19*'\
''-'21*n+.'|'.5$\n+++.@.@\'\\'9$'_'' '4*'_'5*'/
'2$.'   |'++.'  /
'@.' /
'@'/'

Charcoal, 38 37 33 30 bytes

←×_χ↓Ｆ/||⟦ι¹¹⟧\×_⁹‖Ｂ_×ψ⁴↙↙³↑↑³

Try it online! Link is to verbose version of code. Edit: Managed to save a byte with the help of a reflection, although @CarlosAlejo shows that it can in fact be done in 37 bytes without reflecting. Saved a further 4 bytes by drawing the left ¾ and reflecting the final ¼. Edit: Previous 33-byte answer depended on ReflectButterflyOverlap() not overprinting the overlap area with the reflection, so in case this behaviour changed, I sought a solution that didn't rely on that, and the result turned out to be shorter anyway, thanks to my creative use of printing an array. Explanation:

←×_χ                            Print 10 `_`s leftwards (top row)
    ↓                           Move down to the next row
     Ｆ/||                       For each character in the string `/||`
          ι                     Current character
           ¹¹                   Integer 11, prints as `-----------`
         ⟦   ⟧                  Put both into an array
                                Implicitly print on separate lines
              \                 Implicitly print `\`
               ×_⁹              Implicitly print 9 `_`s
                  ‖Ｂ            Reflect right, overlapping the axis
                    _           Implicitly print `_`
                     ×ψ⁴        Implicitly delete 4 characters
                        ↙↙³     Move down left and print three `/`s
                           ↑↑³  Move up and print three '|'s

JavaScript (ES6), 113 112 bytes

(Saved a byte thanks to @Craig Ayre.)

let f=

_=>` _19
/ 19\\
-21
| 19|
-21
| 19|
-21
\\_10 4_5/
 11| 2/
 11| /
 11|/`.replace(/.(\d+)/g,([a],b)=>a.repeat(b))
 
 console.log(f());

C++ 11 - 162 159 154 152 150 bytes

MSVC:

void f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i)cout<<string(*i++-97,*i),i++;}

GCC: (+4 chars)

int f(){char*i="b t_b\nb/t b\\b\nv-b\nb|t b|b\nv-b\nb|t b|b\nv-b\nb\\k_e f_b/b\nl b|c b/b\nl b|b b/b\nl b|b/";while(*i){cout<<string(*i-97,*(i+1));i+=2;}}

Input string i is coded in char pairs:

1. Count of chars to repeat (added to 'a' to be a legible character)
2. Char to print

I think, there's still a lot of room for improvement here.

Edit:

1. Replaced putchar with cout<<
2. Remove while, Use string constructor to repeat chars
3. Removed space before pointer and a spurious semi-colon ;;
4. Compounding instructions with comma, removing braces.

Braingolf, 129 120 bytes

9+.# [#_]#
#/[# ]#\#
&@#
.+>[#-]#
!&@V9+#|[# ]#|#
!&@R!&@v&@R&@934#
..#\[#_][# ][#_]#/#
[# ]"|  /
"[# ]"| /
"[# ]"|/"&@

Try it online!

As always, braingolf is not good at ASCII art

Python 2, 119 117 116 bytes

print''.join(' \n-/|\\_'[ord(x)/8-4]*int('1245abjl'[ord(x)%8],36)for x in' V(8&H(7(@&@(7(@&@(7(HT"S8(%@!8(%@ 8(%@8')

Try it online!

A bit of tortured run-length encoding...

EDIT: Save 3 bytes by replacing the set of lengths:

[1,2,4,5,10,11,19,21][ord(x)%8]

with

int('1245abjl'[ord(x)%8],36)

C (gcc), 187 bytes

Saved 2 bytes thanks to Cody Gray, and 3 bytes thanks to Keyu Gan!

#define a"         "
#define s a" "a
#define l"\n---------------------\n"
f(){puts(" ___________________\n/"s"\\"l"|"s"|"l"|"s"|"l"\\__________    _____/\n"a"  |  /\n"a"  | /\n"a"  |/");}

Try it online!

Python 2, 115 bytes, more creative idea

t,u,v,w,x,y,z='\n -/\\_|';k=w+t+11*u+z;i=t+21*v+t
print u+19*y+t+w+19*u+x+(i+z+19*u+z)*2+i+x+10*y+4*u+5*y+k+u,k,k+w

Try it online!

Python 2, 102 bytes, boring idea

print'eNrjUojHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6XADUmClx'.decode('base64').decode('zip')

Try it online!

Python 2, 159 153 139 bytes

s=" "*19;e="-"*21;a=" "*9;print" %s\n/%s\\\n%s\n|%s|\n%s\n|%s|\n%s\n\%s    %s/\n%s|  /\n%s| /\n%s|/"%("_"*19,s,e,s,e,s,e,"_"*8,"_"*7,a,a,a)

Try it online!

EDIT: Saved 6 bytes by using % formatting instead of .format().
EDIT: Saved another 14 bytes by fixing the output, thanks to musicman523.

Python 3.6, 132 128 125 124 bytes

x,y="_ "
b=y*19
c='-'*21
e=y*11
f=f"{c}\n|{b}|\n"
print(fr''' {x*19}
/{b}\
{f*2+c}
\{x*10+y*4+x*5}/
{e}|  /
{e}| /
{e}|/''')

Try it online!

Charcoal, 38 bytes

←…_χＰ↑⁵Ｐ\Ｆ³«↑Ｐ¹¹↑»↗¹…_χ‖ＢＭ²¦⁷Ｐ↓⁴… ⁴↙↙³

Try it online!

I used Carlos's answer in its original form as a jumping-off point, but saved a good bit by using a reflection, taking advantage of horizontal symmetry. (Vertical symmetry wasn't worth it because the underscores ended up on the wrong row.) You can see the evolution of the canvas at each step here.

Here's the verbose version.

C, 167 bytes

i;char*d=" q    /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/",c,b;main(j){while(c=d[i++],b=c%5==2||c>123?c:c>95?95:c>45?45:c>=32?32:++c,i<47)for(j=c;j-->=b;)putchar(b);}

Try it online!

Note: a lot of apparent spaces above are actually the tab character.

Readable version:

i;
char *d = " q   /()\\   A   |()|    A   |()|    A   \\h#c/  #&|!/   #&| /   #&|/", c, b;
main(j) {
    while(
        c = d[i++],
        b = c % 5==2 || c > 123 ? c:
            c > 95 ? 95:
            c > 45 ? 45:
            c >= 32 ? 32:
            ++c,
        i < 47
    )
        for(j = c; j-- >= b;)
            putchar(b);
}

Explanation:

The data array, d, encodes the answer in literal single characters and coded repeated characters. Each character, c, in the data array is mapped to a base character, b, and a number of repetitions. It is then printed that many times.

Characters that are used only singly (slashes and the pipe) have ASCII codes 47, 92, and 124. Two of these are divisible by 5 with a remainder of 2 (c%5=2||c>123). I couldn't find a shorter condition to test for all three.

Characters that are repeated (underscore, dash, and space), with ASCII codes 95, 45, and 32 respectively, are coded with a higher ASCII code--increased by one per repetition. So, for example, a single space is just a space, but two spaces can be coded by the next ASCII character, the exclamation point. Where a coded character would be unsuitable because it meets the above modulo condition, it can be split, as with #& to represent eleven spaces. The same technique is used to avoid overlap between the space and dash character ranges.

Finally, the ten newlines are encoded as tabs to save bytes that would have been spent escaping the newlines with a backslash, then incremented for printing (++c).

Retina, 74 bytes

 _18¶/ 18\-| 18|-| 18|-\_9 3_4%  % %/
-
¶-20¶
%
/¶ 10|
\d+
$*
+`(.)1
$1$1

Try it online!

///, 98 bytes

/'/  //&/
"""
|!! |//%/\\\/
!'|//#/_____//"/-------//!/'''' / ###____
\/!! \\&&
"""
\\##''#%'% %\/

Try it online! Or, see it interactively!

Zsh, 244 bytes

This is specifically written for Zsh, not Bash, as it allows a bit more in terms of weird syntax.

alias p=printf
function r { p "$1%.s" {0..$2}}
function l { p $1;r $2 19;p $3;p "\n"}
l " " _ " "
l / " " \\
l - - -
l \| " " \|
l - - -
l \| " " \|
l - - -
p \\
r _ 10
r " " 4
r _ 5
p "/\n"
r " " 11
p "|  /\n"
r " " 11
p "| /\n"
r " " 11
p \|/

Note: when I tried to run it on tio.run the output is different than on my terminal. The fix to this is replacing

function r { p "$1%.s" {0..$2}}

with

function r { p "$1%.0s" {0..$2}}

which would make it 245 bytes (link).

Edit Seems like I was too eager to hit that post button and I missed some spaces, making my solution a bit less efficient. My new output seems off though, but I think I counted correctly (but it wouldn't change the length anyway).

SOGL V0.12, 32 31 bytes

^$∙r↑Ψ«2τγæΕž‘╬Æ╬⁷"ƧΡ⅟?0Ξ³‘6«8ž

Try it Here!

Explanation:

...‘               push a quarter of the icon
    Β             palindromize vertically
      ╬⁷           palindromize horizontally (these two should be ╬3 together, but spacing doesn't work correctly (though now it does since I fixed it))
        "...‘      push the extention
             6«8ž  at coordinates [12; 8] in the quad-palindromized image put that in

The quarter:

 __________
/
-----------
|
-----------

and the other part:

    
|  /
| /
|/

Python 2, 124 bytes

a,b,d,e,f,g,h=' _-|/\\\n';r=d*21+h+e+a*19+e+h;n=f+h+a*11+e;print a+b*19+h+f+a*19+g+h+r*2+r[:22]+g+b*10+a*4+b*5+n+a*2+n+a+n+f

Try It Online!

Bubblegum, 40 bytes

Saved 1 byte by removing a trailing newline, thanks @ovs!

00000000: 5388 c704 5cfa 0a98 2086 4b17 1be0 aac1  S...\... .K.....
00000010: a2b6 860a 6a63 10ee 0129 0333 f4b9 9035  ....jc...).3...5
00000020: 2a28 a0f1 51b9 fa00                      *(..Q...

Try it online!

,,,, 115 101 98 bytes

I am absolutely ashamed that this is the best I can produce. >.>

"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #

Python 2, 171 bytes

p,u,q,v,r,s,F=' ','_','/','|','-'*21,'\\',lambda f,m:f+m*19+f;B=lambda n:p*11+v+p*n+q
print'\n'.join([F(p,u),q+p*19+s,r,F(v,p),r,F(v,p),r,s+u*10+p*4+u*5+q,B(2),B(1),B(0)])

Each line is exactly 85 bytes! Hoorah!

Operation Flashpoint scripting language, 263 195 bytes

f={r="                   ";t="---------------------\n";s=" ___________________\n/"+r+"\\n"+t+"|"+r+"|\n"+t+"|"+r+"|\n"+t+"\__________    _____/\n           |  /\n           | /\n           |/";s}

Not the right tool for the job.

Call with:

hint call f;

Output:

The formatting fails, because the font is not monospaced.

Charcoal, 49 37 bytes

↓⁵\…_χ↓↓³↗↗³…_⁵↑/↑⁵↖\←…_¹⁹↓ /Ｆ³«Ｐ²¹¶¶

Try it online!

At last I could golf this a bit. This answer (unlike all other Charcoal answers) does not use reflection, but draws all the contour in one pass, leaving the horizontal bars for the end.

Link to the verbose version.

PHP, 86 bytes

<?=gzinflate(base64_decode("U4jHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6AA"));

Try it online!

PHP, 118 bytes

<?=strtr(' 333____
/00   \
11-
|02
11-
|02
11-
\33    3/
2  /
2 /
2/',['        ','----------',"           |",_____]);

Try it online!

Charcoal, 48 bytes

↙¹→Ｐ¹¹↓↓¹Ｐ¹¹‖Ｂ↓¦↘→×¹⁰_Ｍ⁷↑←←×¹⁰_‖ＢＪ¹¹¦⁶→×⁴ ↙↙³↑↑³

Try it online!

Somewhat different internals than Carlos's, although not visible at first.

Mathematica, 163 bytes

Row@Map[Column,Characters/@{" /-|-|-\\   ",r="_ - - -_   ",r,r,r,r,r,r,r,r,r,"_ - - - |||","_ - - -   /","_ - - -  / ","_ - - - /  ",r,r,r,r,r," \\-|-|-/   "},{1}]

Retina, 89 bytes

1"""____¶/19\¶##-¶|19|¶##-¶|19|¶##-¶\""4"/¶11|2/¶11|1/¶11|/
#
!!
"
_____
!
-----
\d+
$* 

Try it online!

V, 49 bytes

i ±¹_
/±¹ \2ÙÒ-jÓÓ/|
3äkGR\±_´ µ_/
±± |  /2ñÙlx

Try it online!

JavaScript (ES6), 151 bytes

_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

Test Snippet

f=
_=>` 2_________
/0\\
1
|0|
1
|0|
1
\\2    _____/
3|  /
3| /
3|/`.replace(/\d/g,a=>a.repeat.call(...[[" ",19],["-",21],["_",10],[" ",11]][a]))

O.innerHTML=f()

<pre id=O>

Rust, 181 bytes

||" ___________________
/2\\
1
1
3
\\__________    _____/
4|  /
4| /
4|/".replace("1","3
|2|").replace("2",&" ".repeat(19)).replace("3",&"-".repeat(21)).replace("4",&" ".repeat(11))

Try it online!

Rust, 184 bytes

This version may be more golfable as adding further replace cost fewer bytes each. The first replace isn't part of the loop because it pulls double duty changing s into a String instead of a &'static str.

||{let mut s=" 5__5__5
/2\\
1
1
3
\\55    5/
4|  /
4| /
4|/".replace("1","3
|2|");for p in vec![("2"," ",19),("3","-",21),("4"," ",11),("5","_",5)]{s=s.replace(p.0,&p.1.repeat(p.2))}s}

Try it online!

Jelly, 50 48 45 bytes

21“©&Ẇƥ⁸þ/Ẉoụ’ḃ1pF“CṣʠėHẹỊtṡḤḶ’ṃ“ _/\-|”¤xs¹Y

Try it online!