[Question]
  [
Adam West passed away, and I'd like to honor his memory here on PPCG, though I doubt he knew of our existence. While there are many, many different things that this man is known for, none are more prominent than his role as the ~~original~~ batman. I'll always remember my step-father still watching the old-school Batman and Robin to this day. This challenge is simplistic in nature, not at all in line with the complicated man that was Adam West. However, it's the best I could come up with, as this is the most iconic image of the man's career. 
---
*I wanted to post this earlier, but I was waiting for someone to come up with something better.*
---
Output the following (with or without trailing spaces/newlines):
```
           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the lowest byte-count will win.
  
[Answer]
# [Wordfuck](http://esolangs.org/wiki/Wordfuck), ~~5761~~ 2686 bytes
*I guess using his name as a source code gets Adam West some honor.*
```
adam west adam west adam_wes t_a dam_we st_a dam_ west adam west adam west adam west_ad am_west_a dam_we st ad am we st ad am we st ad am west_a dam_we st_a dam_ west_ada m_w est ada m_w est ada m_west_ adam west_a dam_west_ adam_we st_ ad am_west ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_w est_ adam west adam west adam west adam west adam we st_adam west_ad am we st ad am we st adam_w es t_ ad am west_ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am west_a da m_ we st adam_w es t_adam_ west_ad am we st ad am west_a da m_ we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am_wes t_ adam_we st_adam we st ad am_wes t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st adam_w es t_adam_ west_ad am we st_ada m_ we st ad am we st ad am west_ad am we st ad am we st ad am west_a da m_ we st ad am we st ad am_west ad am we st ad am we st ad am_wes t_ ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am_west ad am west_a da m_ we st ad am_west ad am we st ad am we st_ada m_ we st ad am we st ad am we st ad am we st ad am we st ad am west_ad am we st ad am we st adam_w es t_ ad am we st_ada m_ west_ad am_west ad am we st adam_w es t_ ad am west_ad am we st ad am we st adam_w es t_ ad am_west ad am we st adam_w es t_ ad am we st_adam we st ad am west_a da m_ we st_adam we st ad am we st ad am_wes t_ ad am we st_ada m_ west_ad am_west ad am we st ad am we st_ada m_ we st_adam we st ad am we st ad am_wes t_ adam_we st ad am we st ad am_wes t_ ad am west_ad am we st ad am we st_ada m_ west_ad am we st ad am we st adam_w es t!
```
[Try it online!](https://tio.run/##zZLBCsMgEEQ/aMl@wTA/EnJoAoUS6KGQ7zfGGNcYLbSnvIs6syPs6vh5vN7PZZqdE0/fUSIYqAa5mQEIB3QKbUFNl4gokGQP8jKcViviESojUamKMcSW3xD3mLWKS6quhRz1N/hlajfI/NVQmh4uM8o5u8cLs7RMtS2qfyOcUTac1TMPOrcC) (transpiled brainfuck)
[Adam West singing](https://www.youtube.com/watch?v=RgHUGtlvwrY) (thanks @carusocomputing)
[Answer]
## Python, ~~530~~ ~~529~~ ~~528~~ 524 bytes
```
import zlib as Holy
B=list("NNAAAnAAnnAnaAannnaaaaNaAAnNanAaAanNNaNNaNaanNNANanNNANaAnAaANANAAnAaANNnAanAaNnAaAANNAaAnNANAaaANNAanAaNaNNNAaNNanAAnNNnaaaNANANANnnaaaNaaAAAANaNaNaNAnNAAAAaaaaANAaNnnAaAaNAAaANNnaaNnNnaannaaAaananannNnAAAAAanAananANAnaAAnANAAaaaAaaanaaAAaanNAnanAAnnnANAnNAnnAnnnanaNNaaaNaNNaAAnNAaaANNNANAnAaaAaNaANnNNNaaAanaaaanaaaaaAaAaNnNnnaAnANaNnnANanNA")
A=dict(N='11',A='01',n='10',a='00')   
T=""
POP=BIFF=POW=OOF=lambda:A[B.pop()]
while B:T+=chr(int(POP()+POW()+BIFF()+OOF(),2))
print Holy.decompress(T)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 44 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
‚Äú¬°¬©ƒ∞'¬π!√∞kW>·πÖ·πô·∫è·πôl≈ìf:√ü≈í√Ü@∆§‚Äôb25o99Jx$·ªã‚Åæ *s25≈íBY
```
[Try it online!](https://tio.run/##AVAAr/9qZWxsef//4oCcwqHCqcSwJ8K5IcOwa1c@4bmF4bmZ4bqP4bmZbMWTZjrDn8WSw4ZAxqTigJliMjVvOTlKeCThu4vigb4gKnMyNcWSQln//w "Jelly ‚Äì Try It Online")
### How it works
```
‚Äú¬°¬©ƒ∞'¬π!√∞kW>·πÖ·πô·∫è·πôl≈ìf:√ü≈í√Ü@∆§‚Äô
```
This is a numeric literal. All characters are replaced with their 1-based indices in Jelly's [code page](https://github.com/DennisMitchell/jelly/wiki/Code-page) the result is interpreted as a bijective base-250 integer, yielding
```
58616171447449697510361193418481584558895594063391402
```
Next, `b25` convert that integer to base **25** and `o99` replaces **0** with **99**, yielding
```
11 1 20 4 10 1 8 4 12 4 3 6 12 4 2 9 9 5 1 99 1 24 2 5 7 11 4 4 7 3 4 3 7 2 7 1 6 2
```
`Jx$` replaces the **j**th base-25 digits **n** with **n** copies of **j**, yielding
```
1 1 1 1 1 1 1 1 1 1 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 7 7 7 7 7 7 7 7 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 11 11 11 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 14 14 14 14 15 15 16 16 16 16 16 16 16 16 16 17 17 17 17 17 17 17 17 17 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 23 23 24 24 24 24 24 25 25 25 25 25 25 25 26 26 26 26 26 26 26 26 26 26 26 27 27 27 27 28 28 28 28 29 29 29 29 29 29 29 30 30 30 31 31 31 31 32 32 32 33 33 33 33 33 33 33 34 34 35 35 35 35 35 35 35 36 37 37 37 37 37 37 38 38
```
Now, `·ªã‚Åæ *` indexes into the character pair. Indexing is 1-based and modular, so odd numbers get replaced with spaces, even ones with asterisks. This yields
```
           *                    ****          *        ****            ****   ******            ****  *********         ***** *************************************************************************************************** ************************  *****       ***********    ****       ***    ***       **       *      **
```
`s25` chops the result into chunks of length **25**. If we write each chunk on its own line, we get
```
           *             
       ****          *   
     ****            ****
   ******            ****
  *********         *****
 ************************
*************************
*************************
*************************
 ************************
  *****       ***********
    ****       ***    ***
       **       *      **
```
The *bounce* atom `≈íB` palindromizes each chunk by appending a reversed copy without its first character, yielding
```
           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       
```
Finally, `Y` introduces the actual linefeeds.
[Answer]
## JavaScript (ES6), ~~148~~ 146 bytes
```
_=>`n2zh2
f8l2b2l8
b8pep8
7cpepc
5ijiji
3yyq
0
0
0
3yyq
5afy8fa
98f69a96f8
f4f2d6d2f4`.replace(/./g,c=>'* '[(n=parseInt(c,36))&1].repeat(n/2||49))
```
### Demo
```
let f =
_=>`n2zh2
f8l2b2l8
b8pep8
7cpepc
5ijiji
3yyq
0
0
0
3yyq
5afy8fa
98f69a96f8
f4f2d6d2f4`.replace(/./g,c=>'* '[(n=parseInt(c,36))&1].repeat(n/2||49))
o.innerHTML = f()
```
```
<pre id=o></pre>
```
[Answer]
# Python, ~~149~~ 142 bytes
*7 bytes saved thanks to @PM2Ring*
```
for l in"b1d 74a13 54c4 36c4 2995 1o 0p 0p 0p 1o 257b 447343 727162".split():x=''.join(s*int(k,36)for s,k in zip(' *'*3,l));print(x+x[-2::-1])
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~61~~ 59 bytes
```
' *'60:'*u9|K9j[~F9R,>ejc4Q,7;F\1l_=7sFR'F11:ZaY"13e)25ZvZ)
```
[Try it online!](https://tio.run/##y00syfn/X11BS93MwEpdq9SyxtsyK7rOzTJIxy41K9kkUMfc2i3GMCfe1rzYLUjdzdDQKioxUsnQOFXTyDSqLErz/38A)
### How it works
This uses the following, standard techniques:
* Since the image is *horizontally symmetric*, only the left half (including center column) is encoded.
* The image is linearized in column-major order (down, then across) and the resulting sequence is *run-length encoded*.
* The resulting run lengths take values from `1` to `11`, so the sequence of run lengths is *compressed by base conversion*, from base `11` to base `94` (printable ASCII chars except single quote, which would need escaping).
[Answer]
Various solutions, all using Run Length Encoding, with a variety of techniques to encode the RLE data.
## Python 3, ~~125~~ 121 bytes
This version uses a `bytes` string to store the data.
```
s=''
for c in b'<)@4/:),0/>/,3>/*981(WYYY(W*14=./4-.-4+4)2+':s+=' *'[c%2]*(c//2-19);s*=len(s)<25or print(s+s[-2::-1])or 0
```
Let `s` be a string of stars or of spaces. Then the byte `n` encoding `s` is given by
```
n = 38 + 2*len(s) + (s[0]=='*')
```
---
## Python 2, ~~133~~ 126 bytes
This version uses alphabetic coding. The letter value determines the length of the output string, the case of the letter determines whether it's composed of spaces or stars.
```
s=''
for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB':
 s+=' *'[c<'a']*(int(c,36)-9)
 if len(s)>24:print s+s[-2::-1];s='' 
```
---
My original 133 byte Python 2 solution.
This version uses zero-length strings so it can easily alternate between star and space strings.
```
s=''
for c,n in zip(24*' *','b1d074a13054c436c429951o0p0p0p1o257b447343727162'):
 s+=c*int(n,36)
 if len(s)>24:print s+s[-2::-1];s=''
```
---
Just for fun, here's a one-liner using the alphabetic coding.
Python 2, 148 bytes
```
print'\n'.join(''.join(s+s[-2::-1])for s in zip(*[iter(''.join(' *'[c<'a']*(int(c,36)-9)for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB'))]*25))
```
---
For even more fun, [here's a pattern in Conway's Game of Life](https://gist.github.com/PM2Ring/411bdc8b2ba6be278aa25f3cdafdba25) that generates a version of the Batman logo. I had to double each line to keep the aspect ratio roughly the same as the text version. This pattern doesn't *really* compute the logo (although it *is* possible to do computations in Life - it's Turing-complete), it just replays it from memory loops, so I guess I can't post it as a code golfing entry (although I *did* create it using a Python script I wrote a few years ago). ;) 
It's encoded in a fairly standard RLE format that most Life engines can load. If you don't have a GoL program (eg [Golly](http://golly.sourceforge.net/)), you can view it in action online with [this online Life engine](https://copy.sh/life/), which can import Life RLE files. Here's [a PNG version of that Life pattern](https://i.stack.imgur.com/Br984.png), some Life programs (including Golly) can load Life patterns from PNGs and various other image file formats.
[Answer]
# vim, 168 156 bytes
```
:nm N a <C-v><ESC>
:nm A a*<C-v><ESC>
:nm B aY<C-v><ESC>yyp!!rev<C-v><CR>kJh4xo<C-v><ESC>
11NA13NB7N4A10NA3NB5N4A12N4AB3N6A12N4AB2N9A9N5ABN24AB25ABkyyppjN24AB2N5A7N11AB4N4A7N3A4N3AB7N2A7NA6N2ABdd
```
This assumes a Unix environment, for `rev`. I use a fairly straightforward (count,character) encoding, with N and A appending a  and `*` respectively, and B doing the copy and reverse.
In the actual file, the bracketed entries are replaced by the literal bytes they represent. `<C-v>` is 0x16, `<ESC>` is 0x1b, and `<CR>` is 0x0d.
[Try it online](https://tio.run/##XYxBC8IwDIXv@xXZVRiYtluZjEHizUPuHosbiEMdCsX9@pqqoHhI8t6X5MWUNpczCATotlXsu/F@6IuMCMLqDzGE/Rcty1yWtzG@SDHtju5x/XlAFEIr7MURroVU1lkabWyl@SgjLbVSE4vJTsWkwfPpbXXhBZHY6a0XS05LI40aanTwMKSUqvgE)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 47 bytes
```
‚Äû *19√óS‚Ä¢¬´M;√ì8Œ∂?√®Y√ë?¬Ω¬®/≈Ω¬¥.Œ¥√≤√à√ñ<‚Ä¢25–≤—Ç<19«ù√óJ13√§‚Ç¨√ª¬ª
```
[Try it online!](https://tio.run/##AVYAqf8wNWFiMWX//@KAniAqMTnDl1PigKLCq007w5M4zrY/w6hZw5E/wr3CqC/FvcK0Ls60w7LDiMOWPOKAojI10LLRgjwxOcedw5dKMTPDpOKCrMO7wrv//w "05AB1E ‚Äì Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~69~~ ~~54~~ ~~52~~ 48 bytes
```
Ôº•‚™™‚ÄùÔΩú‚Üñy{{Ôπ™yc‚Ä∫o”n‚ÜóœÄf>T‚âîÔºπ¬øPNÔΩúœâœÄÔº±Œ≤‚Äù ‚™´Ôº•Œπ√ó¬ß* Œº‚åïŒ≤Œªœâ‚ÄñÔºØ‚Üê
```
[Try it online!](https://tio.run/##HYxNCsIwFIT3nuKRVSLpBezKjaAoinqB/LyY1Je0tKFaLx9D@WBg4JsxXo2mV1TKbQwp84sa@GOgkDlTSYOy@o2AEcF1HSzwW1mAvAOL1iOYl/aGQUVIOPUhrRdBwjNEnPg@H5PFL2dbYBJidQ4hWa4lkBC1fWq2mzs6QpOvM45U17szuizaUkozl2aiPw "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Edit: Thanks to @ASCII-only, saved 4 bytes by switching from a separate flag to looping over indices, ~~7 bytes by using the (undocumented?) `‚∏ø` character,~~ and a further 4 bytes by using the alphabet for the run length encoding. Saved a further 2 bytes because `AtIndex` automatically takes the modulo. Saved a further 4 bytes because `Map` automatically creates an index variable. Explanation:
```
Print(Map(
```
The outer `Map` returns an array. `Print` handles this by printing each element on its own line, thus avoiding having to manually `Join` them with `\n`.
```
Split("anb adbke eme fjj y z z z y lhf dedhe cgbhc" " "),
```
The string encodes all the half-rows of the output. Alternating letters refer to the number of `*`s and spaces (`a=0` is used to handle a row that starts with a space). The space is a convenient choice of delimiter, but also turns out to compress well (x also compresses to an overall 55 bytes). Each row is processed separately. (Note: The deverbosifier fails to remove the separator between a compressed and uncompressed string, otherwise the code would have a `,` for readability.)
```
Join(Map(i, Times(AtIndex("* ", m), Find(b, l))), w)));
```
Loop over every letter, expanding to the appropriate number of `*`s or spaces. The variable `m` is the inner loop index for this `Map`, while `l` holds the letter. The result is then `Join`ed into a single string using the predefined empty string `w`.
```
ReflectOverlap(:Left);
```
Once all the rows are printed, reflect everything to the left, overlapping the middle column.
I tried handling the newlines, spaces and stars all in one loop but it actually took two more bytes this way:
```
Print(Join(Map("anb adbke eme fjj y z z z y lhf dedhe cgbhc", Ternary(Equals(" ", i), "\n", Times(AtIndex("* ", k), Find(b, i)))), w));
ReflectOverlap(:Left);
```
[Answer]
# Clojure, ~~833~~ ~~437~~ ~~342~~ 332 bytes
Almost by definition Clojure will never win any prizes for brevity, but as I looked forward EVERY DARN WEEK to the TWO (count 'em - **TWO**) episodes of Batman (same Bat-time, same Bat-channel!) it's clear that there is no time to lose!
Quick, Robin - to the Bat-REPL!!!
```
(defn p[](loop[l[[11 1 25 1][7 4 10 1 5 1 10 4][5 4 12 7 12 4][3 6 12 7 12 6][2 9 9 9 9 9][1 47][0 49][0 49][0 49][1 47][2 5 7 21 7 5][4 4 7 3 4 5 4 3 7 4][7 2 7 1 6 3 6 1 7 2]]](loop[a(first l)c " "](print(apply str(repeat(first a)c)))(if(>(count a)1)(recur(rest a)(if(= c " ")"*" " "))(println)))(if(>(count l)1)(recur(rest l)))))
```
Un-golfed version:
```
(defn print-bat-signal []
  (loop [lines [ [11 1 25 1]  ; spaces asterisks spaces asterisks
                 [7 4 10 1 5 1 10 4]
                 [5 4 12 7 12 4]
                 [3 6 12 7 12 6]
                 [2 9 9 9 9 9]
                 [1 47]
                 [0 49]
                 [0 49]
                 [0 49]
                 [1 47]
                 [2 5 7 21 7 5]
                 [4 4 7 3 4 5 4 3 7 4]
                 [7 2 7 1 6 3 6 1 7 2]] ]
    ; (print-bat-signal-line (first lines))
    (loop [ aLine (first lines)
            c   " " ]
      (print (apply str (repeat (first aLine) c)))
      (if (> (count aLine) 1)
        (recur (rest aLine) (if (= c " ") "*" " "))
        (println)))
    (if (> (count lines) 1)
      (recur (rest lines)))))
```
RIP Adam West. No matter how ridiculous those shows were, those of us who were kids salute you.
[Answer]
# [PHP](https://php.net/), 137 bytes
```
<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));
```
[Try it online!](https://tio.run/##BcHbCoIwGADg19GLYIJJUBG/NkMb5iEP6yZM1zyUWhqy3rvr9X1DNUi52W35t@7uj3xiyi0fmaFfS1b0JVNizQIQyM6wRawVBegCT4ALs5PYDo38kHJC2hTTtylIpKH0PNcZ8GdBLRL6CULtQXiGWXFTZwLMS8PHSbxg/OyHeEkbzF3nhI99UHOsqmspf12/KPKiYn8 "PHP ‚Äì Try It Online")
# [PHP](https://php.net/), 177 bytes
```
foreach(["9zojk",a2878,aa4nb,b7u9z,chbf3,eze2n,jz6rj,jz6rj,jz6rj,eze2n,cepdr,ako8z,a1pc1]as$v)echo$t=strtr(substr(base_convert($v,36,2),1),10,"* "),"* "[$k++<2],strrev($t),"\n";
```
[Try it online!](https://tio.run/##VY7LCsIwFER/RUIWqb2CTaUPrPghtUgSbyktJCFNs8h/u65BV8JwGA4MjJ3s3t1t4mgcCjWxnrTRzAsBwZu6ASEuWoKstzaCmuRYAkbkGuZYufmPP6/QvhyIxTQRRGFVMYiVhgzVZKi/rd55x9ZNpsKkWPGpjA7oPKMBygp4BkXKGcjxQLIve7rkeccHSBOHgVGf/EOT676/tTmp9Bk/ "PHP ‚Äì Try It Online")
# [PHP](https://php.net/), 179 bytes
```
for(;$o=ord(kAlgDjAbeDlCcFlCbIiDaWXXXaWbEgJdDgCdBgBgAfA[$i++]);($x+=$s)%24?:print$r.("* "[$k++<2]).strrev($r)."\n".$r="")$r.=strtr(str_repeat($b=+($o>96),$s=$o-64-$b*32),10," *");
```
[Try it online!](https://tio.run/##FY5Ba4MwGEDv@xUlfIPEqGy2FDabFqsO2sN2GVToSjGaRlsx4TOMnfave3bu8i7vHZ5t7Lja2MY@KESDZ1TWoGt7TX/z8/vH5y7NWTxeDNIYjDBY01vS6eyaSJV1afXWpXLXZuWhKIryIHO9rzOd1lu91cklOULL@YnFFH64gIE9RovNq8W2d4AhJd6MHOHG@So6sXBwiOqbArKQfPUkBBSEsKkTk3FIJ/7PqdJRkIJTMOuXJfNhEGCC5SIA6c0j5j8/@WTmkel5vPcmqMqqUX8 "PHP ‚Äì Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 191 bytes
```
#define x 16777215
char*b,*c,a[50];l[]={4096,122888,491535,2064399,4186143,x/2,x,x,x,x/2,4064255,983495,98435,0},*p=l;main(){for(;*p;p++,puts(a))for(b=c=a+23;b>=a;*p/=2)*b--=*c++=" *"[*p&1];}
```
[Try it online!](https://tio.run/##JYtLCoMwGIT3PYW0UDT5RfPShJBeRFzEVFvB2mAfCOLZU6XMYoZvZlx6cy6E07Xt@rGN5ogUZVlSIg7ubifUAHJgK5HXeqhqs/BcFUAolVICV0QwATQvOFMKOJEF4QzmjML815b41lIhQEnG1W58u@QrIG8G/bD9GCdL95xijbz2GIP/vF@xTZKdNcYZiynTzcXYbZAZmqAmTQ1yGJtjhI4V8mdS6zWEkH5/ "C (gcc) ‚Äì Try It Online")
[Answer]
# T-SQL, ~~283 276~~ 222 bytes
```
SELECT CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAFNQgAMtBVxAi5cLxgICdB3IAkAAVYuqEsLHIgRWjV0KqxBIvZYWujQeEaAGLdIALxeJGuinhXSvQEMCPVSQAbIcJPJQReGSSHxU9WAeSppAqEMoBwCfudAGawIAAA=='as XML).value('.','varbinary(max)'))AS varchar(max))
```
Implementing GZIP compression of the original batman string, [via the method posted here](https://codegolf.stackexchange.com/a/190648/70172). This works only in SQL 2016 and later.
For earlier SQL versions, use my prior method (**276 bytes**):
```
DECLARE @ CHAR(999)=REPLACE(REPLACE(REPLACE('PRINT SPACE(11#1$25#1&$7#4$10#1$5#1$10#4&$5#4$12#7$12#4&$3#6$12#7$12#6&$2#9$9#9$9#9&$1#47&#49&#49&#49&$1#47&$2#5$7#21$7#5&$4#4$7#3$4#5$4#3$7#5&$7#2$7#1$6#3$6#1$7#2)','#',')+REPLICATE(''*'','),'$',')+SPACE('),'&',')+CHAR(13')EXEC(@)
```
Basically I'm manually encoding a giant string that determines what to print next, using the following method:
* `#7` gets replaced by `+REPLICATE('*',7)`
* `$4` gets replaced by `+SPACE(4)`
* `&` gets replaced by `+CHAR(13)`
After replacement, the full 958 character string looks like (with line breaks at each line in the Batman symbol:
```
PRINT 
SPACE(11)+REPLICATE('*',1)+SPACE(25)+REPLICATE('*',1)+CHAR(13)
+SPACE(7)+REPLICATE('*',4)+SPACE(10)+REPLICATE('*',1)+SPACE(5)+REPLICATE('*',1)+SPACE(10)+REPLICATE('*',4)+CHAR(13)
+SPACE(5)+REPLICATE('*',4)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',4)+CHAR(13)
+SPACE(3)+REPLICATE('*',6)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',6)+CHAR(13)
+SPACE(2)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+SPACE(2)+REPLICATE('*',5)+SPACE(7)+REPLICATE('*',21)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(4)+REPLICATE('*',4)+SPACE(7)+REPLICATE('*',3)+SPACE(4)+REPLICATE('*',5)+SPACE(4)+REPLICATE('*',3)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(7)+REPLICATE('*',2)+SPACE(7)+REPLICATE('*',1)+SPACE(6)+REPLICATE('*',3)+SPACE(6)+REPLICATE('*',1)+SPACE(7)+REPLICATE('*',2)
```
Which gets executed as dynamic SQL, producing the following output:
```
           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       *****
       **       *      ***      *       **
```
[Answer]
# [Python 2](https://docs.python.org/2/), 134 bytes
```
for w in'1D 4A13 4C4 6C4 995 O P P P O 57B 47343 27162'.split():r=''.join(c*int(k,36)for c,k in zip(3*'* ',w));print'%25s'%r+r[-2::-1]
```
[Try it online!](https://tio.run/##HYxLCsIwFACv8jblJTEt5NOWRlz42de9uCpIYyUJaaDo5WOUYXbDhHeavZM5P3yEDaxDcQF9FAr0WUNXHIYWRrj@GaHtT6B7pRXIXnQSmzW8bCLUxANi8/TWkYlZl8jCVUd/04kvZQsfG4hiyAD5Ruk@xBJhJdsVq7iLt1oaU4t7zl8 "Python 2 ‚Äì Try It Online")
Run-length encodes each line from the left half in base 36. Mirrors it to make the full line, which is printed. The leading spaces are not encoded; instead, the left half is padded to length 25.
[Answer]
# Java, ~~296~~ 214 bytes
Golfed:
```
()->{String r="";boolean b=1<0;for(int a:";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()){for(int i=0;i<a-48;++i)r+=(b?'*':' ');if(a<49)r+='\n';else b=!b;}return r;}
```
Ungolfed:
```
public class InHonorOfAdamWest {
  public static void main(String[] args) {
    System.out.println(f(() -> {
      String r = "";
      boolean b = 1 < 0;
      for (int a : ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()) {
        for (int i = 0; i < a - 48; ++i) {
          r += (b ? '*' : ' ');
        }
        if (a < 49) {
          r += '\n';
        }
        else {
          b = !b;
        }
      }
      return r;
    }));
  }
  private static String f(java.util.function.Supplier<String> f) {
    return f.get();
  }
}
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~129~~ 128 bytes
```
-join('5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% t*y|%{(' ','*')[$i++%2]*($_-42)})-split'(.{49})'-ne''
```
[Try it online!](https://tio.run/##FcTRCoIwFADQX/FBuduu9253zUEQ9NBXSERPQsZQSSFC/fZV5@FM47t7zY8upZzpOfaDggYveOKAFgNHjhLZu9/OHv6oxdks2JKVs1jHQmyZhJta0JFDqWGrisV8tmpVUEANBvS17BErfzOqvFPwetc0T6lfQPEajrsGGjqAnL8 "PowerShell ‚Äì Try It Online")
Ungolfed:
```
-join(
    '5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% toCharArray|%{
        (' ','*')[$i++%2]*($_-42)
    }
)-split'(.{49})'-ne''
```
Output:
```
           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **
```
## Main idea is very simple
The Emblem Coding:
1. Concatenate all emblem lines to one string
2. Count spaces and asterisks
3. Encode length of each segment + 42 as a char
Decoding (this script):
1. Get code of the char minus 42 for each char from the cripto-string. This is a length of a segment
2. Append segment, consisting of a space or asterisk repeated `Length` times
3. Insert new line each 49 symbols to split lines
## Some smart things
1. The coding algorithm suggests a symbol with code 189 to display 3 middle asterisk lines. This symbol is not ASCII. It works normal with modern environments, but there are ambiguities with script length. So, I replace non-ascii-symbol `¬Ω` to `s*t` (73 asterisks, 0 spaces, 74 asterisks).
2. I cut off right spaces in the last line to save 1 byte. Sorry, Batman.
3. Why the offset is 42? Just wanted :) And cripto-string looks nice.
## Extra: Scipt for coding of the Emblem
```
(@"
           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       
"@ -replace"`n"-split'( +|\*+)'-ne''|%{[char]($_.Length+42)})-join''
```
[Answer]
# [Bubblegum](https://esolangs.org/wiki/Bubblegum), 75
xxd dump:
```
00000000: cd92 b501 8050 1043 fb4c 91fa efbf 1f0e  .....P.C.L......
00000010: 2f87 d371 5814 37d3 7c35 4d2b 1826 64f6  /..qX.7.|5M+.&d.
00000020: d8aa 419c 2a11 3e75 ce25 6d1e ee9d 22e0  ..A.*.>u.%m...".
00000030: bb11 f04f 0d7f 2e38 dfc8 6926 3dad 0871  ...O...8..i&=..q
00000040: f316 1071 6db8 fc07 a408 f7              ...qm......
```
[Try it online](https://tio.run/##VZA9SwRBDIZ7f8WL4BUKcTLfKyiIraKl7c5kcghuccV2/vc1590VvhBIkTw8SVtb@x77ddk2d84DukweLTlGdcmBXQzQFjsm1hlDm4LVDYCO@aAXev3r6OpEYGN4rQUSCiNVjghFAkoPCVF8A1efkaNm4J7o8EmFftLbHe3kwvDGkDrPiDx1@JkZYZSEPnxCFh4YYxJ4P9zR45lu6Wmlm8Usri@MYIzWbFNdVDgpCj9ChWivyJMpBJkFrprl8ZZ3q0r0tXs0pzMjGkMDZ/uCTWVpFdpdwRyddQX/YvuH5fSKbfsF).
[Answer]
# Coffeescript (282 Bytes)
```
t=['6bk','59mw','l2j3','2ghsf','4zg2n','9zldr','jz6rj','4u7zz','165qf','47wj']
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d)->parseInt(t[d], 36).toString(2).padStart 25, '0').forEach (d)->console.log (d+d.split('').reverse().join('').substring(1)).replace(/0/g, ' ').replace(/1/g,'*')
```
### Explaination (using plain-ol ES6)
* Like other's mentioned, the image is symmetric, so we can toss out half of it in the encoding
* Several lines are also repeated, so we can toss each line in a lookup table to save a few bytes
* We convert each half-line into binary (using 0 as space and 1 as \*), and encode it at that highest radix in Javascript (36), resulting in the encoding array.
* First map takes each line and converts it back into its final output half-line, padding it with 0s
* Second map concatenates each line with its reversed half (tossing the middle column the second time), and replaces the 0s and 1s with spaces and \*s
```
var t = [
    '6bk',
    '59mw',
    'l2j3',
    '2ghsf',
    '4zg2n',
    '9zldr',
    'jz6rj',
    '4u7zz',
    '165qf',
    '47wj'
];
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d) => {
    return parseInt(t[d], 36).toString(2).padStart(25, '0');
})
.forEach((d) => {
    console.log((d + d.split('').reverse().join('').substring(1))
        .replace(/0/g, ' ')
        .replace(/1/g, '*'));
});
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), 102 bytes
```
i¬±¬≥ *¬±¬± 
¬≥ *¬± ¬¥*¬∑ 
¬¥*¬±¬≤ ¬¥*¬µ 
¬¥*¬±¬≤ ¬∂*¬≥ 
¬µ*¬π ¬π*  
¬≤¬¥* √Ñ3o¬≤¬µ*jo¬±¬±*¬∑ ¬µ*  
¬≥*¬¥ ¬≥*¬∑ ¬¥*¬¥ 
**¬∂ *¬∑ **¬∑ √é√¶$vp
```
[Try it online!](https://tio.run/##TYwhEoAwEAN9v1ATgYrlVWBA8QI0z8ADLQw2fVi5A4PZyd5lMtXaadMBGjeEL0GJusySn/dX809PWi8oUzd0E5Z3eyKWuR0sZsZ@8EFfMfPCQSU4r3cuIZA64U5HLEtZm2ms9QE "V ‚Äì Try It Online")
Hexdump:
```
00000000: 69b1 b320 2ab1 b120 0ab3 202a b120 b42a  i.. *.. .. *. .*
00000010: b720 0ab4 2ab1 b220 b42a b520 0ab4 2ab1  . ..*.. .*. ..*.
00000020: b220 b62a b320 0ab5 2ab9 20b9 2a20 200a  . .*. ..*. .*  .
00000030: b2b4 2a20 1bc4 336f b2b5 2a1b 6a6f b1b1  ..* ..3o..*.jo..
00000040: 2ab7 20b5 2a20 200a b32a b420 b32a b720  *. .*  ..*. .*. 
00000050: b42a b420 0a2a 2ab6 202a b720 2a2a b720  .*. .**. *. **. 
00000060: 1bce e624 7670                           ...$vp
```
This uses run-length encoding to generate the following batman half:
```
             *           
   *          ****       
****            ****     
****            ******   
*****         *********  
************************ 
*************************
*************************
*************************
************************ 
***********       *****  
***    ***       ****    
**      *       **      
```
And then reverses and duplicates each line.
[Answer]
## Mathematica 151 Bytes
```
Uncompress@"1:eJxTTMoPCm5iYmBQQAAtBVxAK8bA0AjGBgJ0PcgCQABXjaoWwsciBFWPXRKrEESHlha6AjwiYC1apAGQHhK10FsTOV6Chgp6CCEDZDlYdKKKw6WR+OjxD+KiJBSEQoR6AC49ZiI="
```
Cheap and uncreative. The string is just from the built-in `Compress` command used on the required output.
Update:
I think I can do better with the built-in `ImportString` \ `ExportString` functions but I can't see to copy and paste the resulting strings from `ExportString` correctly. E.g.
```
b = "           *                         *\n       ****          *     *          ****\n     ****            *******            ****\n   ******            *******            ******\n  *********         *********         *********\n ***********************************************\n*************************************************\n*************************************************\n*************************************************\n ***********************************************\n  *****       *********************       *****\n    ****       ***    *****    ***       ****\n       **       *      ***      *       **"
ExportString[b,"GZIP"]
ImportString[%,"GZIP"]
```
I can not seem to copy the text output from the second line to replace the `%` in the third line.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), ~~407~~ 322 bytes
```
w=`yes 1|head -30|tr -d '\n'`
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
x=`printf "%.$[0x${a}]d%.$[0x${b}]s%.$[0x${c}]d%.$[0x${d}]s%.$[0x${e}]d%.$[0x${f}]s" 0 $w 0 $w 0 $w`
echo -n $x$[f<1?0:1]
rev<<<$x
}|tr 01 \ \*
```
[Try it online!](https://tio.run/##bZDdaoNAEIXv9ykOYUvagmVWVyXBUPrzFlFw1d0qBC1raCzRx@611dAQL3oz58w3A3OYTLXlOJ526bduIfpSqwKOR/3Rwimwjut1ykxjUaGq8SreiAihfBEuwZdT58ELLuJuNkQS04ZPAej9H/mbuX7okw8pQ0@6CN1QBIKdYefTChlyFNAwiKKI3@u8bMCrHqY5TMlEj07Zj/aBdbv001b10WB198T31PGzGpLi6rMhaa8@X/BiwfWCm4mvQOCnW0nZ5bpTg3d8byLxTFuRMKu/5mgdG@YvkUCM@HEcf@rGyVVe6l8 "Bash ‚Äì Try It Online")
really awful, need more time or help to golf it.
it generates the output with 0 an 1 and transliterates in the end.
Encoded in hexa digits the amount of 0 and 1, taking care to make last digit 0 for the first two rows as a flag to output middle column.
Uses printf pressision to either digit or string to output 0 and 1.
think the `%.$[0x${X}]C` pattern could be used to golf it.
```
w=`yes 1|head -30|tr -d '\n'`  # w=111111111111111111111111111111   
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
printf "%.$[0x${a}]d
%.$[0x${b}]s
%.$[0x${c}]d
%.$[0x${d}]s
%.$[0x${e}]d
%.$[0x${f}]s" 0 $w 0 $w 0 $w
echo -n $[f<1?0:1]
printf "%.$[0x${f}]s
%.$[0x${e}]d
%.$[0x${d}]s
%.$[0x${c}]d
%.$[0x${b}]s
%.$[0x${a}]d\n" $w 0 $w 0 $w 0 
}|tr 01 \ \*
```
[Answer]
# Python 3, ~~232~~ ~~197~~ ~~183~~ 164 bytes
Yet Another Python Answer. No boring compression code though. Exciting compression code.
```
for s in map(lambda x:x+x[-2::-1],b".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&".split()):print(*((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)))
```
I'm using the magic number 35 because that way, no control characters, spaces or things that would need to be escaped occur. Sad that I have to process the spaces and stars separately, that costs me a bit.
### Ungolfed:
```
for s in map(lambda x:x+x[-2::-1],   # map a list to the list and itself reversed,
                                     # minus the last (center) element
# magic string:
".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&"
.split()):                           # split on whitespace to divide into lines
 print(*(                            # unpack generator expression
(ord(s[i])-35)*" "                   # convert character to int, -25, times space
+(ord(s[i+1])-35)*"*"                # same thing with "*"
for i in range(0,len(s)-1,2)))       # for every pair in the list
```
[Answer]
## PowerShell, 305 bytes, 307 bytes, 316 bytes
```
[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()
```
Maybe someone else can help me shorten it further, though I can't figure out how unless there's a more concise way to define a custom type accelerator.
Edit: Shortened version (thanks @root). Encoded string (pre base64 encoding) can be trimmed by eight array positions and the range can be thus decreased. Not sure why StreamWriter is introducing this bloat into the MemoryStream. Insight into the underlying behavior would be appreciated.
```
[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg')),0,94),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()
```
Ungolfed:
```
#Read decoded stream 
[IO.StreamReader]::new(
    (
        #Reverse GZip encoding
        [IO.Compression.GZipStream]::new(
            #Load GZip encoded string into a memory stream
            [IO.MemoryStream]::new(
                (
                    # Convert Base64 back to GZip encoded string
                    [Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')
                ),
                #Start of range
                0,
                #End of range. Stick the Memory Stream into a variable and use .Length here for non golf code
                102
            ),
            #Specify that we are decompressing
            [IO.Compression.CompressionMode]::Decompress
        )
    )
).ReadToEnd()
```
Compression code:
```
$s = '           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **'
#Create Memory Stream
$ms = [IO.MemoryStream]::new()
#Initialize a stream
$sw = [IO.StreamWriter]::new(
    #Create GZip Compression stream
    [IO.Compression.GZipStream]::new(
        #Reference Memory Stream
        $ms,
        #Set mode to compress
        [IO.Compression.CompressionMode]::Compress
    )
)
#Write input into stream
$sw.Write($s)
#Close the stream
$sw.Close()
#Convert Array to Base64 string
[Convert]::ToBase64String(
    #Retrieve Memory Stream as an array
    ($ms.ToArray() | select -SkipLast 8)
)
```
[Answer]
# Perl 5, 168 bytes
```
$_="11 *25 
7 4*10 *5 *10 4
5 4*12 7*12 4
3 6*12 7*12 6
2 9*9 9*9 9
 47
49
49
49
 47
  5*7 21*7 5
4 4*7 3*4 5*4 3*7 4
7 **7 *6 3*6 *7 *";s/$/*/gm;say s/\d+(.)/$1x$&/ger
```
Note the trailing space at the end of only the first line. Requires `-M5.01`, which is free.
Can probably be golfed quite a bit more.
[Answer]
# [CJam](https://sourceforge.net/p/cjam/wiki/Home/), 78 bytes
```
"@√á√è√ü√ø√ø√ø√ø√ø√ø√ø√ø√ø√ø√ø√ø√Ω√ø√ø√≥√ø"{8{_2U#&'*S?\}fU;}/]25/{_24/~;W%N}%
```
[Try it online!](http://cjam.aditsu.net/#code=%22%00%08%00%00%0F%40%C2%80%07%C2%80%C3%87%0F%00%C3%8F%7F%00%C3%9F%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BF%C3%BD%C3%BF%C3%BF%C3%B3%01%C3%BF%C2%87%07%1C%0E%18%10%18%22%7B8%7B_2U%23%26'*S%3F%5C%7DfU%3B%7D%2F%5D25%2F%7B_24%2F~%3BW%25N%7D%25)
---
How it works:
Like many other submissions, this takes advantage of vertical symmetry so that only the following data has to be encoded:
```
           *             
       ****          *   
     ****            ****
   ******            ****
  *********         *****
 ************************
*************************
*************************
*************************
 ************************
  *****       ***********
    ****       ***    ***
       **       *      **
```
Since all lines are 25 characters long, we can drop all newlines:
```
           *                    ****          *        ****            ****   ******            ****  *********         ***** *************************************************************************************************** ************************  *****       ***********    ****       ***    ***       **       *      **
```
This string only contains spaces and `*`, so it's the perfect candidate for a bitmap. 8 characters are chunked into one with a `1` bit meaning `*` and `0` meaning space. The string is 325 characters long, so it's padded with 3 additional spaces to be dividable by 8. This yields the binary string:
```
@√á√è√ü√ø√ø√ø√ø√ø√ø√ø√ø√ø√ø√ø√ø√Ω√ø√ø√≥√ø
```
Now, onto the code part:
```
{8{_2U#&'*S?\}fU;}/]25/{_24/~;W%N}%     e# for each character do:
 8{_2U#&'*S?\}fU                        e#   for U in 0..7 do:
   _2U#&'*S?\                           e#     push (char & pow(2, U)) ? '*' : ' '
   _                                    e#     duplicate the character
    2U#                                 e#     push pow(2, U)
       &                                e#     bitwise-AND the char with the value
        '*                              e#     push '*'
          S                             e#     push space
           ?                            e#     ternary select
            \                           e#     swap the pushed char with the original (for next loop iteration)
                ;                       e#   pop the character (from last loop iteration) from the stack
                    ]                   e# wrap all pushed chars in one array
                     25/                e# split array after every 25 elements (chars)
                        {_24/~;W%N}%    e# for each char group do:
                         _24/~;W%N      e#   mirror string and append newline
                         _              e#   duplicate string
                          24/           e#   split at 24 chars
                             ~          e#   dump array to stack
                              ;         e#   pop top stack element
                               W%       e#   select every -1th element (reverse)
                                 N      e#   push newline
```
[Answer]
# LaTeX, 314 bytes
```
\documentclass{book}\begin{document}\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}\catcode`.13\catcode`!13\catcode`-13\def!#1{\r*{`#1}}\def-#1{\r~{`#1}}\let.\par\tt-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B\enddocument
```
The ungolfed version with explanations:
```
\documentclass{book}
\begin{document}
% Macro for repeating #1 (#2-64) times
\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}
% Prepare '.', '!' and '-' for usage as macro names
\catcode`.13\catcode`!13\catcode`-13
% The ASCII code of #1 (a character) is used as the number of how often '*' will be printed with \r
\def!#1{\r*{`#1}}
% Same as ! but for spaces
\def-#1{\r~{`#1}}
% . becomes a line break
\let.\par
% Set monospace font
\tt
% And finally print the whole thing
-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.
!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B
\enddocument
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 342 333 328 185 175 bytes
```
_=>{var r="";for(int i=0,j,k=0;i<63;i++)for(j=0;j++<"-#;#4&,#'#,&.&.).&*(.).('+++++%Q#¬µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)"[i]-34;){r+=i%2<1?' ':'*';if(++k%49<1)r+='\n';}return r;}
```
[Try it online!](https://tio.run/##bY/NasJAFIX3PsWQcX6ukwSt0tJOYimF7gqVLlxYKdMYZdRMYGYUiuSxfIG@WJoYsJt@i3Mv99yzOJmLstLmdbZXzqE3W26sKnqo4XTRFueV1xk6lnqFXpU23HmrzWaxRMpuHFz//hIt79/O50X8cjBZ0gXCbkzRl/KFMiitP9Pp6agssmkQyHVpuTYe6XQYbsNdOpQ6uR1LLQS01rY5bIVIgghLPKEhZjikMY0hpgPeKGeihczwzxnPCIM7YJwCoYwSoFEfMCccQx@ChV5G44mEkxWpJjfJ6JEh9sAGTOo1F2JHJvfJCBqTfRgmK5v7gzXIyqqWvf8qPpfGlfs8nlvtc96V48HTShVonjsfAMhrrLpsVf0L "C# (.NET Core) ‚Äì Try It Online")
Lots of bytes saved after changing the approach. Taking the drawing as a 2D array, I calculated the RLE encoding by files:
```
{ 11, 1, 25, 1, 18, 4, 10, 1, 5, 1, 10, 4, 12, 4, 12, 7, 12, 4, 8, 6, 12, 7, 12, 6, 5, 9, 9, 9, 9, 9, 3, 47, 1, 147, 1, 47, 3, 5, 7, 21, 7, 5, 6, 4, 7, 3, 4, 5, 4, 3, 7, 4, 11, 2, 7, 1, 6, 3, 6, 1, 7, 2, 7 }
```
Odd indices stand for s and even indices stand for `*`s. Then I substituted every number for a printable ASCII representation (taking the '#' character as 1), and I got:
```
-#;#4&,#'#,&.&.).&*(.).('+++++%Q#¬µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)
```
So the algorithm just calculates the drawing by decompressing this string and adding newlines in the proper places.
[Answer]
# [Brainfuck](https://github.com/TryItOnline/brainfuck), 369 bytes
```
+[[->>>+<<<]>+++++++>+++>+]-<-<<<--<-<<<-<<--<<<-<<+<+<<<<---<<++<---<<<<<+<---<+<++<<<+<[->++<]<<<<<++<-----<<[[-]<]+<-<[++<<+<]>[>>>]<<<<+<+<<<+<<<+<<<+<--<[[->+++++>>]<[<<<]>]+<+<+++++<<<+++++<<<+++++<-------<+<++<+++<<[+++<]<++<------<+<<+++<<[+++<]<<----[<+<]<+[----<]<---<+<<<--<+<+[-<+++>]+<+<<---<++<++++++++[-<+<++++<++++>>>]<--<+>>+[-[-<.>]<<<[->>>+<<<]>>>>+]
```
[Try it online!](https://tio.run/##VVDLDsJACPyV3gm99OCF8COEQ2vUGBtNfBz8@hWG1VSSDY8ZGNjlPp@vx9f@0hqZsaqSiLhSmeI5C0eVu0MET5LsSDOm8pLljChLmcTYiLwgYMkLNRePVCx5QVALea8B1fl9wTdMyXWCYtjRCRpUMn@ey2oHAEbY4Yfl5C2Asgk4BoL3K3AuZTUbSrWgrh5m3FeRWlEdTfGbxoGNOGvzvRl4O93mdZh207C8n4dH@wA "brainfuck ‚Äì Try It Online")
General idea is to fill memory with counts for how many spaces, stars, and newlines to output (the character to write is the position modulo 3), terminated by a `255`. To efficiently build the counts the symbol is broken into a bottom half, which is prefilled with `0 7 3`, and the top half which is prefilled with `0 9 4`.
`+[[->>>+<<<]>+++++++>+++>+]-` Fills the memory with 254 repetitions of `0 7 3` terminated with a `255`, not all of them are used but its easier to create that many than any other count.
`<-<<<--<-<<<-<<--<<<-<<+<+<<<<---<<++<---<<<<<+<---<+<++<<<+<[->++<]<<<<<++<-----<<[[-]<]+<-<` Updates the counts of the bottom half, note the `[[-]<]` which zeros 3 consecutive cells and is used as a marker for changing the cell repetitions and to compact the middle 5 lines into a loop.
`[++<<+<]>[>>>]` Update remaining cells to be repetitions of `0 9 4`.
`<<<<+<+<<<+<<<+<<<+<--<[[->+++++>>]<[<<<]>]+<+<+++++<<<+++++<<<+++++<-------<+<++<+++<<[+++<]<++<------<+<<+++<<[+++<]<<----[<+<]<+[----<]<---<+<<<--<+<+[-<+++>]+<+<<---<++<` Update the counts of the top half.
`++++++++[-<+<++++<++++>>>]<--<+>>+[-[-<.>]<<<[->>>+<<<]>>>>+]` Output the characters. The first loop builds `42 32 10`, second loop outputs the right most character n times and then moves the left most character forwards 3 cells and repeats until a `255` is hit.
[Answer]
# Mathematica, 271 bytes
```
T=Table;f[x_]:=""<>T["*",x];m={f@49};n={f@47};g[y_]:=""<>T[" ",y];k[a_,b_,c_,d_,e_]:={(s=f@a<>g@b<>f@c<>g@d<>f@e)<>StringDrop[StringReverse@s,1]};Grid@{k[1,13,0,0,0],k[4,10,1,3,0],k[4,12,0,0,4],k[6,12,0,0,4],k[9,9,0,0,5],n,m,m,m,n,k[5,7,0,0,11],k[4,7,3,4,3],k[2,7,1,6,2]}
```
]