[Question]
  [
# Challenge
Print or return the Stack Exchange favicon, as provided below:
```
 ___________________
/                   \
---------------------
|                   |
---------------------
|                   |
---------------------
\__________    _____/
           |  /
           | /
           |/
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in each language wins.
  
[Answer]
# [Operation Flashpoint](https://en.wikipedia.org/wiki/Operation_Flashpoint:_Cold_War_Crisis) 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.
[![](https://i.stack.imgur.com/4RdFw.jpg)](https://i.stack.imgur.com/4RdFw.jpg)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~38~~ ~~37~~ ~~33~~ 30 bytes
```
←×_χ↓Ｆ/||⟦ι¹¹⟧\×_⁹‖Ｂ_×ψ⁴↙↙³↑↑³
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMPKJzWtREchJDM3tVhDKV5JR8HQQFPTmss3vyxVw8olvzwPyEnLL1LQUNKvqVHSVIBoi84EKjSMBcpB@EoxMUpwDpJhliCzglLTclKTS5xKS0pSi9JyKjUQ2uLRdVXqKJig2g9yIFwRXERHwRiuKrQAIR9aAJb5//@/btl/3eIcAA "Charcoal – 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
```
[Answer]
# [///](https://esolangs.org/wiki////), 98 bytes
```
/'/  //&/
"""
|!! |//%/\\\/
!'|//#/_____//"/-------//!/'''' / ###____
\/!! \\&&
"""
\\##''#%'% %\/
```
[Try it online!](https://tio.run/##JcwxCoAwEETRPqfYZEm2kn@hAbEQLOzS5u4x6qsGhpl@H/06@5wEZtBIpZQ0crYBFUmkHCs7@wsK2w8ysRjm7m@ZxBpKrX0vknuE16hWxZwP "/// – Try It Online") Or, [see it interactively!](http://conorobrien-foxx.github.io/slashes.html?JTJGJyUyRiUyMCUyMCUyRiUyRiUyNiUyRiUwQSUyMiUyMiUyMiUwQSU3QyEhJTIwJTdDJTJGJTJGJTI1JTJGJTVDJTVDJTVDJTJGJTBBISclN0MlMkYlMkYlMjMlMkZfX19fXyUyRiUyRiUyMiUyRi0tLS0tLS0lMkYlMkYhJTJGJycnJyUyMCUyRiUyMCUyMyUyMyUyM19fX18lMEElNUMlMkYhISUyMCU1QyU1QyUyNiUyNiUwQSUyMiUyMiUyMiUwQSU1QyU1QyUyMyUyMycnJTIzJTI1JyUyNSUyMCUyNSU1QyUyRg==)
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/##JYrBCsIwEAXvfkVv1bwtukEPpeRPAl4NgVhkt2mC/x5TPM0wzFrk9U62NSGljTLtVKi60adhunr//I5LdBkCZqOoS3ACy2aDnNZPSDIoeDalD/kQxY5zQP17vRiL0BPf@nLv5dEZoRQpIrf2Aw "Python 2 – Try It Online")
# [Python 2](https://docs.python.org/2/), 102 bytes, boring idea
```
print'eNrjUojHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6XADUmClx'.decode('base64').decode('zip')
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM69EPdWvKCs0P8vDya3KzLkgPT0juzjCXdu5sDzR2ygjvaAwssKl1DE428VXP9g02yW00NvbpSI0Kc8swtElNNc5p0JdLyU1OT8lVUM9KbE41cxEXRMuUJVZoK75/z8A "Python 2 – Try It Online")
[Answer]
# 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());
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~32~~ 31 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
^$∙r↑Ψ«2τγæΕž‘╬Æ╬⁷"ƧΡ⅟?0Ξ³‘6«8ž
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTVFJTI0JXUyMjE5ciV1MjE5MSV1MDNBOCVBQjIldTAzQzQldTAzQjMlRTYldTAzOTUldTAxN0UldTIwMTgldTI1NkMlQzYldTI1NkMldTIwNzclMjIldTAxQTcldTAzQTEldTIxNUYlM0YwJXUwMzlFJUIzJXUyMDE4NiVBQjgldTAxN0U_)
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:
```
    
|  /
| /
|/
```
[Answer]
# 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!](https://tio.run/##JYpBDsIwDAS/0lul2AhiwQGivIQglKpJzcVUUS9I/D1sxcH2rGfXz6Zvk94zTzxz4coLaxyH5@F7TCnZGFqcnXhSKpSdv@JosFjxQPRUwtpetg2Zpt0q1X9tATYn1O43kQci9AnqDLiQgWTfmNr7Dw)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 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!](https://tio.run/##bY7BCsIwEETv/YplemkPNR@g@CULEpJUA3EV0p5Mvz0mQltB57JvhmVnzXA1JrdeTJito1OcrH8cbufcWjd6caRBq9CsYawx9OYDWIZ/YkEzdv3rOU@xA11@xaIQwYyAVCB9TeZ9rfZ/QJWT9adEtONGCv1xyXftpZSW4mLe "C (gcc) – Try It Online")
[Answer]
# 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!](https://tio.run/##Rc4xDoIwGEDhubdAiKYVkFggBkppPIc40B@UEgRFiIP17CgsLu9bH7hXgMlSLTRjURrJcyhUt6vSSTGo8n5bcNN4IA@TLENHpDHRf7KsssBD1kavlhpLPdMBR7Jbrlpck/erUk2JgRcnZdtnR3JYh5xTrSHdU19ADGkUiij8GYQimOU@FT6NbRsclQQHcul6XHNgteumXDJyH4f5DUvCPtP0BQ "C (gcc) – 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`).
[Answer]
# [Rust](https://www.rust-lang.org/), 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!](https://tio.run/##ZYvBCsIwEETv@Yp1D7IL0ZCkF/FXAhIkQqGGEuup6bfHNAdbdBaGZd5Mer@m8ojw9H0knsfUx2mIB8J5QUklZ4Tbv4Qyzgldzwrnthyq2qNElwGar6bwnMI4@Hsg1CjRimwy8hYalEeE1gp@In3hHbQrPH2h0XvY/SwrLEzM16V8AA "Rust – Try It Online")
## [Rust](https://www.rust-lang.org/), 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!](https://tio.run/##PYzBCsIwEETv@YrtHiQLsTVpcxDxS6yUIhEKNYYk9dL022taxNlh4O3A@CnE9Wnh1Q@W0@z8YONoC47zgoKvKc2jifCaIoQrgu66zaxSbctkvpq1rdaQpSvWJIA9t6iw9MaN/cNwlCiwZkklpMvz7cHBYOFjHsWNo8odoJBnEhzrDEcUSm7Q/JoddIYOhab7HK7hP@3Kkzi4Um4P08fMimgJy0qc6LKsXw "Rust – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 49 37 bytes
```
↓⁵\…_χ↓↓³↗↗³…_⁵↑/↑⁵↖\←…_¹⁹↓ /Ｆ³«Ｐ²¹¶¶
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R2@RHjVtjHjUsiz/fDuK0TT60@VHbdCAC0kBRoOyjton6QAxmTYt51DYBJH5o56PGnUDVCvrv9yw7tPnQ6vd7NhzadGjnoW2Htv3/DwA "Charcoal – 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](https://tio.run/##S85ILErOT8z5/z@gKDOvRMPKJb88T0fBVNOaCyKgFBOjBOcEJealp2ooxSvpGBpoAkV988tSIVrgSqAGGMNlQwuCMtMzShAKoAIQNejmAm1GVqmjoKSvhCpgisz1SU0DGoTiRiuIGJKRhpaa6M5TUgAbm5ZfpKBhrKlQzeVbmlOSWQBWYmSI5Pm8mDyQwtr////rlv3XLc4BAA).
[Answer]
# [Bubblegum](https://esolangs.org/wiki/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!](https://tio.run/##bYw7DgIxDER7TjElUFh2fptwBSpES@NECRKCcs8fvGJLnjRTzby61vruz/UzJ@9cEH3OaAsHxDYUrCXDcU4IVRZI7QzVJsCdiB4W0JU2Dj@DmENdTciJFUmTh3DvYHEF7L3HCLWgsI/A9ns1qxN567g7nDmcugzlIYhi@6HM@Mv5SHSz85xf "Bubblegum – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 38 bytes
```
←…_χＰ↑⁵Ｐ\Ｆ³«↑Ｐ¹¹↑»↗¹…_χ‖ＢＭ²¦⁷Ｐ↓⁴… ⁴↙↙³
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R24RHDcviz7e/37PhUdvER41bgYyY93uWHdp8aDVQAMg7tPPQTiDr0O5HbdOBLLDqRw3T3u9Z9H7P2kObDi171LgdrHvyo8YtQGkFENU2E4gObf7/HwA "Charcoal – Try It Online")
I used [Carlos's answer in its original form](https://codegolf.stackexchange.com/a/129306/16766) 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](https://tio.run/##S85ILErOT8z5/1/hUdvER20THjUsiz/f/n7Pkvd7NoBEGrdC2DFgatmhzYdWA4WBAod2HtoJZi05tPtR2/RDO4EsuOZHDdPe71kE1rL20KZDyx41bgebN/lR4xaIOgUoq20mEB3a/P8/AA).
Here's the [verbose version](https://tio.run/##XY9RC4IwFIXf9ysue9qFCZlF0KP0FAki9CaEyKbCcrKmEdFvXw4x0tfvfJxzb1kXptSFci41TWvZ8SKk5ZAVbSUYvVEO4QaRJL2yTTcZ147DfoFonlMkUhtgEcKbJHoQ3ltIYYh/wYekc1vWVPU4OcYTWm9nQipR2ri3VhipXgzJub93bMsPy8NO@tly2K16gHo2b3vHvzhLP8AhQudcMLjgob4).
[Answer]
# 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!](https://tio.run/##K6gsycjPM/r/v6AoM69EXV0vKz8zT0NdISZPV78mJiZePTq/KEWjQlPfQtckVguoREPd0MjENDEpKwcmpWoRq2NsppmWX6RQoZCZp64QpmGh5qFhruGg5gAnPUKUgi00VB0UQYQCiLBQ1/z/HwA "Python 2 – 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)`
[Answer]
# 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.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 74 bytes
```
J*21\-L*db+d*19\_++\/y19\\V2J++\|y19\|;J++++\\*T\_y4*5\_\/V3+++y11\|y-2N\/
```
[Try it online!](https://tio.run/##K6gsyfj/30vLyDBG10crJUk7RcvQMiZeWztGvxLIiAkz8gKya0DsGmsgE8iJ0QqJia800TKNiY/RDzMGClUaGgKV6Br5xej//w8A "Pyth – Try It Online")
[Answer]
## [R16K1S60 Assembly](http://lbphacker.hu/powdertoy/R16K1S60/manual.md), ~~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
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~50~~ ~~48~~ 45 bytes
```
21“©&Ẇƥ⁸þ/Ẉoụ’ḃ1pF“CṣʠėHẹỊtṡḤḶ’ṃ“ _/\-|”¤xs¹Y
```
[Try it online!](https://tio.run/##AWEAnv9qZWxsef//MjHigJzCqSbhuobGpeKBuMO@L@G6iG/hu6XigJnhuIMxcEbigJxD4bmjyqDEl0jhurnhu4p04bmh4bik4bi24oCZ4bmD4oCcIF8vXC184oCdwqR4c8K5Wf// "Jelly – Try It Online")
[Answer]
# [V](https://github.com/DJMcMayhem/V), 49 bytes
```
i ±¹_
/±¹ \2ÙÒ-jÓÓ/|
3äkGR\±_´ µ_/
±± |  /2ñÙlx
```
[Try it online!](https://tio.run/##K/v/P1Ph0MZDO@O59EGUQoy00eGZhyfpZh2efHiyfg2X8eEl2e5BMYc2xh/aonBoa7w@F1DZRoUaBQV9oMqNh2fmVPz/DwA "V – Try It Online")
[Answer]
# Mathematica, 163 bytes
```
Row@Map[Column,Characters/@{" /-|-|-\\   ",r="_ - - -_   ",r,r,r,r,r,r,r,r,r,"_ - - - |||","_ - - -   /","_ - - -  / ","_ - - - /  ",r,r,r,r,r," \\-|-|-/   "},{1}]
```
[Answer]
# [PHP](https://php.net/), 86 bytes
```
<?=gzinflate(base64_decode("U4jHBFz6CpgghksXG+CqwaK2hgpqYxDuASkDM/S5kDUqKKDxUbn6AA"));
```
[Try it online!](https://tio.run/##K8go@P/fxt42vSozLy0nsSRVIymxONXMJD4lNTk/JVVDKdQky8PJrcrMuSA9PSO7OMJd27mwPNHbKCO9oDCywqXUMTjbxVc/2DTbJbTQ29ulIjQpz8zRUUlT0/r/fwA "PHP – Try It Online")
# [PHP](https://php.net/), 118 bytes
```
<?=strtr(' 333____
/00   \
11-
|02
11-
|02
11-
\33    3/
2  /
2 /
2/',['        ','----------',"           |",_____]);
```
[Try it online!](https://tio.run/##K8go@P/fxt62uKSopEhDXcHY2DgeCLj0DQwUFBRiuAwNdblqDIxQ6BhjY6CcgrE@l5GCAogAYn11nWh1BShQ11HXhQN1HSUFBKhR0gGZHx@raf3/PwA "PHP – Try It Online")
[Answer]
## 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!
[Answer]
# 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](https://tio.run/##fY3RCsIwDEXf9xUh1EfbZeqDDP@kIEMYFkot7Xxx7bfXtAqCiFxIcs8lySNeS5msmSL4kw/GLXM3391lMTcHAVbwgII2MiKsvZRiyPmT25YLGgOIAeg4stlxQe0wdxaQda6VZ9Wc1jxuq7jr9GLpL/N1KfAd6rnVcN/sgRNU/OlNiSpIAD/YN9JJlfIE) 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](https://tio.run/##fY3BCsIwDIbve4oQ6tG1mXqQ4ZsUZAjDQqmlnRfXPntNqyCISCDJ/@VP8ojXUiZrpgj@5INxy9zNd3dZzM1BgBU8oKBNryLCqvpeDDl/DLYZBI0BxAB0HFnsOKF2mDsLyHGumXvZlNbcbmtw1enF0l/m61LgO6S41OG@yQNPUPKnNyWqIAH8YN9IJ1nKEw)).
**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).
[Answer]
# [Retina](https://github.com/m-ender/retina), 74 bytes
```
 _18¶/ 18\-| 18|-| 18|-\_9 3_4%  % %/
-
¶-20¶
%
/¶ 10|
\d+
$*
+`(.)1
$1$1
```
[Try it online!](https://tio.run/##K0otycxL/P@fSyHe0OLQNn0FQ4sY3RogWQMlY@ItFYzjTVQVFFQVVPW5dLkObdM1Mji0jUuVS//QNgVDgxqumBRtLhUtLu0EDT1NQy4VQxXD//8B "Retina – Try It Online")
[Answer]
# 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!](https://tio.run/##K6gsycjPM/r/v9hWSUFJy9DSOtVWSVdJy8jQOhEsYmldUJSZV6KkoFock6cPJGJi8kDMGtXiGnRWjGqxAhCoFuuD@DUKClAaQukrqWooxYPs0CnWSYVjkJAFmDTXSQRBzf//AQ)
EDIT: Saved 6 bytes by using `%` formatting instead of `.format()`.  
EDIT: Saved another 14 bytes by fixing the output, thanks to musicman523.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~79~~ ~~72~~ 71 bytes
```
" _p
/ p\\
{"-r
| p|
"²}-r
\\_g a_b/
 h|  /
 h| /
 h|/"r".%l"_g p6nZÅnH
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=IiBfcAovIHBcXAp7Ii1yCnwgcHwKIrJ9LXIKXFxfZyBhX2IvCiBofCAgLwogaHwgLwogaHwvInIiLiVsIl9nIHA2blrMbkg=&input=)
* 7 bytes saved thanks to ETHproductions' excellent suggestion of using base 32 integers for the repetition values.
[Answer]
# 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>
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 89 bytes
```
1"""____¶/19\¶##-¶|19|¶##-¶|19|¶##-¶\""4"/¶11|2/¶11|1/¶11|/
#
!!
"
_____
!
-----
\d+
$* 
```
[Try it online!](https://tio.run/##K0otycxL/P@fy1BJSSkeCA5t0ze0jDm0TVlZ99C2GkPLGkxmjJKSiZL@oW2GhjVGEMoQQulzKXMpKnIpcYEMiudS5NIFAa6YFG0uFS2F//8B "Retina – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 48 bytes
```
↙¹→Ｐ¹¹↓↓¹Ｐ¹¹‖Ｂ↓¦↘→×¹⁰_Ｍ⁷↑←←×¹⁰_‖ＢＪ¹¹¦⁶→×⁴ ↙↙³↑↑³
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R28xDOx@1TXq/Z8OhnSDWZCA6tBPGbZj2fs8ikMiyR20zgMoOTwcKNm6If79n7aPG7Y/aJj5qmwBEMGGI@vd7VoE0A/U0bgPredS4RQFoEciuzWA9Ew9t/v8fAA "Charcoal – Try It Online")
Somewhat different internals than Carlos's, although not visible at first.
[Answer]
# [,,,](https://github.com/totallyhuman/commata), ~~115~~ ~~101~~ 98 [bytes](https://github.com/totallyhuman/commata/wiki/Code_page)
I am absolutely ashamed that this is the best I can produce. >.>
```
"|/
"' 11×:"| /
"⇆:"|  /
"⇆'
'/'_5×' 4×'_10×92c'
'|' 19×'|'
'-21×+++++3×110⇆⊣"\
"' 19×'/'
'_19×' #
```
]