tinylisp, 460 bytes

(d K disp
(d E(q((X)(i(e X 42)32(i(e X 62)41(i(e X 60)40 X
(d D(q((S)(i S(c(E(h S))(D(t S)))(
(d C(q((S)(string(D(chars S
(K(C(q *_***_******_*_*****************************_*****_*_
(K(C(q |*|*|*|*___|*|*|*___****__******_____**_*__|*|*__|*|*|
(K(C(q |*|_|*|/*_*\*|*|/*_*\***\*\*/\*/*/*_*\|*'__|*|/*_`*|*|
(K(C(q |**_**|**__/*|*|*<_>*|***\*V**V*/*<_>*|*|**|*|*<_|*|_|
(K(C(q |_|*|_|\___|_|_|\___<*>***\_/\_/*\___/|_|**|_|\__,_<_>
(K(C(q ********************|/

Try it online!

Basically hard-coded, with substitutions required for spaces and parens.

Fig, \$274\log_{256}(96)\approx\$ 225.535 bytes

Dr_tem[82]\r-reIX3vb/pBNI9@xbV1?^csytMxrA)YVtY.5yfDryr#(K{bAe,YSkOIU9\|tet&RZF_n+!\;TlNE'T3OB{GGqqvpiP 61;Y#nh0^=vOX6@vxmixkmqp<&y<%;b?=|FG&!6*XI*<glXG,bt|0Kv`/lO;OEx7[`$vT4ljhkSGVaE'</\z{uF8L2E2yXU%r\Ws9F;cF4FXZVD}TL?qdxQ;slDX~lyO# K_+lFV52P-Io9a.7JuDaWJ/sAo,lCChg=5 P9^=[B

Try it online!

Boring text compression answer. Doesn't compress very well due to the compressor being much more optimized for words and spaces before words than characters. Fun fact: when designing Fig, I was considering making the compressor use RLE in the character case, but decided to do capitalization instead :(

Stax, 137 bytes

"9&BO]h>&)>3ieuCoKVKVnuOoT'E-^Z(1.3u[);h1[RTOGqTZkoQx?KMy&9ctG&*y~HxR9%GYn.rYMdMcOOq^wXc@%zy*P[*Q"90|E|B"0+1"{%",``_|\/()V'"@]}R.1 |t54/m

Run and debug it

It works like this.

1. Start with a big string literal.
2. Convert to integer by decoding as a base-90 number.
3. Convert that number to binary.
4. Runs of 0s followed by a 1 are translated into non-space characters.
5. All remaining 1s are replaced with spaces.
6. The resulting string is split into 54-character lines.

PowerShell, 220 byes = script:9 + archive:211

tar xOf t

Try it online!

The Powershell script to create the archive t (see TIO):

(
" _   _      _ _                             _     _ _",
"| | | | ___| | | ___    __      _____  _ __| | __| | |",
"| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |",
"|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|",
"|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)",
"                    |/"
) | Set-Content f -Force
tar zcfo t f
Get-ChildItem t # output info about archive size

Pylongolf2, 300 bytes

" _   _      _ _                             _     _ _
| | | | ___| | | ___    __      _____  _ __| | __| | |
| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |
|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|
|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)
                    |/"~

I couldn't find any classy encoding methods, so I'm probably not competing.

In other languages: C (original version), 209 chars; Perl, 200 chars.

J, 167 160 chars (47 + 113)

Another no-builtin-compression submission. Uses a pretty straightforward variable-length encoding, encoding each character as a series of 1 bits and separating characters by 0 bits. The compressed string is a mere 113 characters.

('a _|\/',CR,'()V`,'''){~#;.2,(6$2)#:40-~3&u:'8H1(((((H:f[4ZS4ZP2(RPMAMANf[>CZD[F;I[OVFF;TgfS5aGd[7T9JW4[eG[+Of7ddg?d[.AfT]WUASE=S>bSdgI]cS[RWBYSE?gSeG_X(()WG('

bash, 196 192

base64 -d<<<H4sIAO4SqFMCA3VPQQ7AIAi7+4re5pIl/GYnk+4hPH4U0dOmILUUUBCAPEOBn8Wlao65SW6QudWJSYSUM5sqlQlZJAY2QPiAhSEJx8GSPVWm0TppOa3z1DWqboRZEY7K5pzmMw49kgU6TtXRwiDCpCrZxejTvn7u1l5z59MGKQEAAA|zcat

PHP 590

obviously, i'm not trying to win, just got interested on trying another compression scheme, altough it can't even beat the simpler 302 plain text PHP solution of just copy-pasting

it works as a bitmap on 10 channels

"golfed"

<? $l=['_'=>['l8kqo,ei','9uo6,2fko0','52m0w,5r1c','540lc,5maq','lifeo,19i7ai'],'|'=>[0,'1h39j4,105','1h2k8w,q9x','14l2jk,wlx','1h39j4,wlc','1s,0'],'/'=>[2=>'b9c0,n3kao','pa8,18y68','0,mihog','w,0'],'\\'=>[2=>'pc5,a0zy8','2,0','b9c1,am2kg'],'('=>[3=>'e8,b8lc','1s,4'],')'=>[3=>'3k,2t4w','g,1'],'V'=>[3=>'0,18y680'],'`'=>[2=>'0,g'],"'"=>[2=>'0,6bk'],','=>[4=>'0,g'],];$p=@str_pad;$b=@base_convert;$i=-1;while($i++<5){$h=' ';foreach($l as$c=>$r)if(@$r[$i]){$a=explode(',',$r[$i]);$d=str_split($p($b($a[0],36,2),27,0,0).$p($b($a[1],36,2),27,0,0));foreach($d as$j=>$v)$v&&$h[$j]=$c;}echo"$h\n";}

readable

<?php
$l = ['_'=>['l8kqo,ei','9uo6,2fko0','52m0w,5r1c','540lc,5maq','lifeo,19i7ai'],
      '|'=>[0,'1h39j4,105','1h2k8w,q9x','14l2jk,wlx','1h39j4,wlc','1s,0'],
      '/'=>[2=>'b9c0,n3kao','pa8,18y68','0,mihog','w,0'],
     '\\'=>[2=>'pc5,a0zy8','2,0','b9c1,am2kg'],
      '('=>[3=>'e8,b8lc','1s,4'],
      ')'=>[3=>'3k,2t4w','g,1'],
      'V'=>[3=>'0,18y680'],
      '`'=>[2=>'0,g'],
      "'"=>[2=>'0,6bk'],
      ','=>[4=>'0,g'],
      ];
$p=@str_pad;
$b=@base_convert;
$i=-1;
while($i++<5){
    $h = str_repeat(' ',54);
    foreach($l as $c=>$r)
        if(@$r[$i]){
        $a = explode(',',$r[$i]);
        $d = str_split($p($b($a[0],36,2),27,0,0).$p($b($a[1],36,2),27,0,0));
        foreach($d as$j=>$v)
            if ($v)
                $h[$j]=$c;
        }
    echo "$h\n";
}

Perl, 346 bytes

The compressed string alone, is 111 bytes.

@t = split//, " _|\\/\n()V',`";
$k=[0,[1,[2,[[3,4],[[5,6],[7,[[8,9],[10,11]]]]]]]];

$b .= substr unpack("B8", chr(-48+ord)), 2, 6 for split//,'@P900000PBlc<b[<bX:0ZXUIUIVlcFKZLI^Y`LLMhjjW<oJcMGncNHS5MIW]l`ho3lMNgc<IW]V]i[=KUF]KUG[hL^l^^EMeSFiGmNggP001^Pl';

$d = $k;
$o.=$d=~/^\d/?$t[$s=$d,$d=$$k[$_],$s]:($d=$$d[$_],"")for split//,$b;
print $o

Trying to understand what the python with key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2))) was doing, I ended up making a very similar looking perl version.

HTML + JS (223 unicode characters)

Just for fun:

<body onload=p.innerHTML=unescape(escape("𘁟𘀠𘁟𘀠𘀠𘀠𧰠𧰠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𧰠𘀠𘀠𧰠𧰊𯀠𯀠𯀠𯀠𧱟𧱼𘁼𘁼𘁟𧱟𘀠𘀠𧱟𘀠𘀠𘀠𧱟𧱟𧰠𘁟𘁟𧱼𘁼𘁟𧱼𘁼𘁼𒡼𘁼𧱼𘁼𛰠𧰠𧀠𯀠𯀯𘁟𘁜𘀠𘁜𘁜𘀯𧀠𛰠𛰠𧰠𧁼𘀧𧱟𯀠𯀯𘁟𨀠𯀠𯀊𯀠𘁟𘀠𯀠𘁟𧰯𘁼𘁼𘀨𧰩𘁼𘀠𘁜𘁖𘀠𥠠𛰠𚁟𚐠𯀠𯀠𘁼𘁼𘀨𧱼𘁼𧱼𒡼𧱼𘁼𧱼𧁟𧱟𯁟𯁟𯁜𧱟𧰨𘀩𘀠𘁜𧰯𧁟𛰠𧁟𧱟𛱼𧱼𘀠𯁟𯁜𧱟𛁟𚁟𚐊𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𘀠𯀯").replace(/uD./g,''))><pre id=p>

NB: you have to save it in a "UTF-8 with BOM" HTML file.

Perl, 294 290 bytes.

The compressed string alone, is 151 130 bytes.

This isn't short, but it was really fun to write.

@t=split//,"_|\\/\n()V',`";$b.=substr unpack("B8",chr(-48+ord)),2,6 for split//,'Ph?`@Ooooo1l410````0066600?03l0001PP06600HHB1Q064L4D<8h8^::<DLL4@J0032>1D<90h<>00hHI@6QhYllLX3@`hHI@1Q04P@1Q04@002080R001I^80a074001Q07208P0B0X34ooo`ST';$b=~s/(1)|(0.{4})/$1?" ":$t[ord pack"B8","000$2"]/eg;print$b

@t=split//," _|x"x4 ."\\/\n()V',`";$b.=substr unpack("B8",chr(-48+ord)),2,6 for split//,'4100A0000000001017:8R5HR5@1@05E15R5R;:9Ra4`8\\A<0<30a`<C4C2=URa7PRbP@PG4R<g@P<3D=C4cM288S=RK:HV`EVK1G<d0`LL74`EaV2K1Mg=db0000002ab';$b=~s/1(1.{4})|(..)/$t[ord pack"B8","000".($2?"000$2":$1)]/eg;print$b

This answer is longer than just printing the string; however, just for the fun of it, here it is:

Python, 485 characters ☺

import sys

data= ',C6UBKq.)U^\\ 8[hHl7gfLFyX6,;p\'SlYpN@K-`Kbs#fSU+4o~^_h\\dJDy{o9p?<GnLTgG{?ZM>bJE+"[kHm7EavoGcS#AQ^\\>e_'
table= " _|\\/(\n)V'`,"
key= (0,(1,((((7,5),(6,(8,(11,(9,10))))),(4,3)),2)))

number= 0
for char in data:
    number= number*95 + ord(char) - 32

mask= 1<<655
decoder= key
while mask:
    index= mask & number and 1
    try:
        decoder= decoder[index]
    except TypeError:
        sys.stdout.write(table[decoder])
        decoder= key[index]
    mask>>= 1

Since I have one of the shortest ASCII representations of the compressed original text, I must have the longest scrollbar in my code! It's a win! :)

Golf-Basic 84, 325

:"                     "_Str1t` _   _      _ _ "d`Str1d`Str1t`_     _ _"t`| | | | ___| | | ___    __      _____  _ __| | __| | |"t`| |_| |/ _ \ | |/ _ \   \ \ /\ / / _ \| '__| |/ _` | |"t`|  _  |  __/ | | (_) |   \ V  V / (_) | |  | | (_| |_|"t`|_| |_|\___|_|_|\___( )   \_/\_/ \___/|_|  |_|\__,_(_)"t`                    |/"

Assuming a calculator could print backticks, backslashes, single pipes, and underscores.

Javascript, 273 265 264 characters

" _2_22_ _2222222226_26_ _10 0 3_0 | 3_2 32233_6_ 30 30 |10_0/ _ 4 0/ _ 424 4 /4 / / _ 4| '30/ _` 01|6_6|63/ 0 (_) |24 V6V / (_) 060 (_0_|1|_0_|43_|_543_( )24_/4_/ 43_/56543,_(_)12222226|/".replace(/\d/g,function(a){return'| |,\n,   ,__,\\,|_|,  '.split(',')[a]})

:(

Perl 5.10 - 195 198 202 203 characters

Here's an entry that does not require any libraries beyond basic regexp matching. The encoded string is 131 characters, and the code to decode and print it takes up 64 characters (assuming no newline at the end of the source). The idea is to represent common 3-character strings by lower case letters.

s!!xfefxxf\t\t\tf efyx
no| cnocfxefxceyxm|xmn
nm|wtnwtgt/uvy \\| 'ym|w`o|
pepyy/o| _ogrr/ _opn (ml
l lbyly|by( )fiihyjm lb,y_
\t\tf |/!;s!\w!substr'(_)\___   \_/|_| |  V \ / _',-95+ord$&,3!eg;say

The encoder is a lot longer and unfortunately not very readable right now. The basic idea is to use dynamic programming to find the shortest encoding for each line, given a fixed set of string substitutions. The string of substitutions on the last line was built by trial and error, and it is possible that another string of substitutions might lead to a shorter program than above.

One trick here is that some substitutions are shorter than 3 characters long: due to the way perl substr works, x is replaced by ' _' and y by '_'. The latter is necessary because \w in the regex matches '_', which is then replaced by '(_)'.

Python (2.x), 194 characters

print'eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'.decode('base64').decode('zip')

Bash, 199 196 193 characters

base64 -d<<<H4sIAAAAAAAAAz1PQQ6AIAw7S+IfelMTk/3GE0l9CI+3HRPYoHQtAxCAMzduGliMiL0NzElygSz+LiYhLWc1VekzDFU6FoCyIxRIYuBgyd7f5+5eGdnv5OWjbA8UUcRAVbORfBN0v5MFTlw2MhQwEVaV7KYu2tv88IgPjUlb7QoBAAA=|zcat

Close enough...

EDIT: Down to 193!

PHP, 194 189 characters

php -r'=gzinflate(base64_decode("dU/BDcQgDPszhX+lUqVs0xeSb5AMf3ZI+7qDACa2EwABeNXR4M/goxqJPUm+oLinEishKTdbKtuMQsTCC6C1EApUInHIvOlP+9zbO6PaTZ6+ynZDEZ1INFuNRu5z+ZVsMHHax1DAibCqZRdVZ/z6esYX"));'

It's basically the same as the Python and Perl answer, slightly shorter

Perl, 230 characters

use Compress::Zlib;
use MIME::Base64;
print uncompress(decode_base64('eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc'));

This is basically the same as my Python answer. I'd like to see the 199-character version.. sounds like magic.

Python (2.7.x), 218 characters

import base64,zlib;
print zlib.decompress(base64.b64decode("eNo9T8ENxCAMe5cp/DsqVco2fSH5BsnwZ4ccEIhxbAIgAK9KvDRwGBEjsSfJA6r2N7EISbmrpbLNKFRYOABaC6FAEYkPW/Ztm1t7Z1S3ydtHuV4ooolEV6vPyJ2XH8kGE7d9DAVMhFUte6h7xv5rxg8sf0Qc"))

Pretty straightforward... not terribly pleased with this attempt.

Brainfuck - 862 characters:

>++++[<++++++++>-]>-----[<---->---]<+++>>--[<+>--]<---<<.>.<...>.<....
..>.<.>.<.............................>.<.....>.<.>.>>++++++++++.<.<<.
>>.<<.>>.<<.>>.<<.>...>.<<.>>.<<.>>.<<.>...<....>..<......>.....<..>.<
.>..>.<<.>>.<<.>..>.<<.>>.<<.>>.>.<.<<.>>.<.>.<<.>>.>>>-[<->+++++]<---
-.<<<<.>.<.>---.+++<.>>.<<.>>.>>.<<<<.>.<.>---.<...>.<.>.<.>>>>.<<<.<.
>>>>.<<<<.>>>>.<<<<.>+++.<.>---.>.<<.>>>>>>---[<+>+++++++]<++.<<<<+++.
.>.<<.>>.>>.<<<<.>.+.-<.>>.<<.>>.>.<.<<..>.<..>>.<<..>..>>>.<<<<.>>.<<
.>>.<<.>>>>>+.<<<<.>>>>+.<<<<<.>>.<<...>---.<.>------.<..>.<.>>>>.<<<<
.>>>>>-.<<<<+++++++++.>>>>+.<<<<<.>>.<<.>>.<<..>>.<<.>>.<<.>>>>>-.<<<<
.>.<<.>>.<.>.>.<.<.>.<<.>>.<.>.<---.+++...>.<.>.<.>.<---.+++...>>>>.<<
<<<.>>>>>+.<<<<<...>---.+++.>>>.<<<---.+++.>>>.<<<<.>---.+++...>>>.<<.
<.>.<<..>>.<.>.<---.+++..>>>>+++.<<<<.>>>>----.<<<<.>>>>+.<<.<<<......
..............>>.>>.<.