[Question]
  [
This challenge is in honor of mathematician [John Conway](https://en.wikipedia.org/wiki/John_Horton_Conway) who [passed away April 11, 2020 due to COVID-19](https://dailyvoice.com/new-jersey/mercer/obituaries/covid-19-kills-renowned-princeton-mathematician-game-of-life-inventor-john-conway-in-3-days/786461/). He was famous for coming up with the [Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life) cellular automaton and [many](https://en.wikipedia.org/wiki/John_Horton_Conway#Major_areas_of_research) [other](https://en.wikipedia.org/wiki/List_of_things_named_after_John_Horton_Conway) mathematical contributions such as the [surreal numbers](https://en.wikipedia.org/wiki/Surreal_number) and the [monster group](https://en.wikipedia.org/wiki/Monster_group).
The advanced math of those topics is out scope for this programming challenge, though I strongly recommend people watch the various [Numberphile videos about Conway](https://www.youtube.com/playlist?list=PLt5AfwLFPxWIL8XA1npoNAHseS-j1y-7V). In [one of those videos](https://youtu.be/xOCe5HUObD4?t=453) Conway says that he'd like to know why the [monster group](https://en.wikipedia.org/wiki/Monster_group) exists before he dies. It's unfortunately too late for that now but we can honor his memory in a very small way by exploring in code the strange number associated with the group.
# Challenge
The [monster group](https://en.wikipedia.org/wiki/Monster_group) is the largest [sporadic simple group](https://en.wikipedia.org/wiki/Sporadic_group) in the branch of [group theory](https://en.wikipedia.org/wiki/Group_theory) in mathematics. But the only thing to know for this challenge is that its [order](https://en.wikipedia.org/wiki/Order_(group_theory)), or number of elements it contains is:
```
808017424794512875886459904961710757005754368000000000
```
Your task is to write a program that outputs this number. *However*, to keep this from being trivial, your program may not contain any digits, 0 through 9. That is, **your program may not contain any of the ten characters `0123456789`**.
Your output must be the precise digits of the number:
```
808017424794512875886459904961710757005754368000000000
```
or the digits with appropriate commas:
```
808,017,424,794,512,875,886,459,904,961,710,757,005,754,368,000,000,000
```
(Commas `,` are allowed in your code.)
Any [usual output method](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods?answertab=votes#tab-top) is valid. No input should be required. **The shortest program in bytes wins.**
If it helps anyone the factorization of the number is:
```
2^46 * 3^20 * 5^9 * 7^6 * 11^2 * 13^3 * 17 * 19 * 23 * 29 * 31 * 41 * 47 * 59 * 71
```
(Factorization is not valid output.)
  
[Answer]
# [Sledgehammer](https://github.com/tkwa/Sledgehammer), 4 bytes
 31 bits, to be overly specific   
please upvote the author of this awesome language instead of me
```
‚£∂‚£ñ‚°•‚£ï
```
(this is a very awesome Mathematica compressor, and it ***really*** excels at compressing code with only a few powerful built-ins)
In this case, the built-ins are `GroupOrder` and `MonsterGroupM`, because of course they exist.
In case this somehow helps, the exact bits contained in the code are `01110111 01110101 10110010 1011010`, the corresponding Mathematica code is `GroupOrder@MonsterGroupM[]`, and the internal suffix code is `call["MonsterGroupM", 0], call["GroupOrder", 1]`, where 0 and 1 are the argument counts.
[Answer]
# [Python 2](https://docs.python.org/2/), 61 bytes
Port of [Neil's answer](https://codegolf.stackexchange.com/a/203529/88546).
*-5 bytes thanks to @Surclose Sputum!*  
```
for i in"  @@G^dddrstuuuvwxxy{|~~~~~":True*=ord(i)
print True
```
[Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SCFTITNPSUHBwcE9LiUlpai4pLS0tKy8oqKyuqYOBJSsQopKU7Vs84tSNDI1uQqKMvNKFEBC//8DAA "Python 2 ‚Äì Try It Online")
---
# [Python 3](https://docs.python.org/3/), ~~60~~ 58 bytes
*Thanks to @Surculose Sputum for saving 2 more bytes!*
```
k=True
for i in b"?G^dddrstuuuvwxxy{|~~~~":k*=i+i
print(k)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P9s2pKg0lSstv0ghUyEzTyFJyd49LiUlpai4pLS0tKy8oqKyuqYOCJSssrVsM7UzuQqKMvNKNLI1//8HAA "Python 3 ‚Äì Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 21 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
‚Å¥·∏§¬Æx‚Äú√Ü√ë¬•¬©¬µ"¬µ¬£‚Ç¨√ó ≈ì‚Äò;√Ü¬°
```
**[Try it online!](https://tio.run/##ATQAy/9qZWxsef//4oG04bikwq544oCcw4bDkcKlwqnCtSLCtcKj4oKsw5cgxZPigJg7w4bCof// "Jelly ‚Äì Try It Online")**
### How?
$$|M|=13\times 43!+16\times 42!+4\times 41!+6\times 40!+9\times 39!+34\times 38!+9\times 37!+2\times 36!+12\times 35!+17\times 34!+32\times 33!+30\times 32!$$
So...
```
‚Å¥·∏§¬Æx‚Äú√Ü√ë¬•¬©¬µ"¬µ¬£‚Ç¨√ó ≈ì‚Äò;√Ü¬° - Main Link: no arguments
‚Å¥                     - literal 16
 ·∏§                    - double = 32
  ¬Æ                   - recall from register = 0
   x                  - times = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
    ‚Äú√Ü√ë¬•¬©¬µ"¬µ¬£‚Ç¨√ó ≈ì‚Äò    - list of code-page indices = [13,16,4,6,9,34,9,2,12,17,32,30]
                  ;   - concatenate = [13,16,4,6,9,34,9,2,12,17,32,30,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
                   √Ü¬° - convert from factorial base to integer
```
---
For what it's worth a naive base-250 compression is 25 bytes AND contains digits: `‚Äú√Ü4·∏å‚Åπ|oGO‚Å∑pNJ6√æ·∏§)ƒñ‚ÅΩu2·∫è·∫è≈º‚Äô`
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~32~~ 29 bytes
```
Ôº©Œ†Ôº•/Gdddrstuuuvwxxy{|~~~~~‚äó‚ÑÖŒπ
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9npXnFrzfs1TfPSUlpai4pLS0tKy8oqKyuqYOBB51TX/U0npu5///AA "Charcoal ‚Äì Try It Online") Explanation: Converts the characters to their ASCII character codes, doubles them, then takes the product. Edit: Saved 3 bytes by porting @SurculoseSputum's golf of @dingledooper's Python 3 answer.
However, Charcoal can just compress the output text... except that compression of the whole text includes an `8`, so you have to print it in two parts:
```
‚Äù)¬∂‚Ä≥¬≥L‚¨§j$a‚óßEœÑB‚äü[Œ≤œâ‚Åµ‚Üì‚âßÔºØ‚Äù‚Äù|ÔΩû‚ÖâE
```
(Compressing the string in the first program doesn't help as the resulting string contains a digit.)
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvREPJwsDCwNDcxMjE3NLE1NDIwtzUwsLMxNTS0sDE0szQ3NDA3NTcwMDU3NTE2ExJ05oLrg0GgIL////XLcsBAA "Charcoal ‚Äì Try It Online") Link is to verbose version of code.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~34~~ 32 bytes
*Thanks @my pronoun is monicareinstate for shaving 2 bytes!*
Someone has to do this...
```
Print@GroupOrder@MonsterGroupM[]
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/z@gKDOvxMG9KL@0wL8oJbXIwTc/r7gktQgs4hsd@/8/AA "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 67 bytes
```
"nn/HM|Q:iv^YxO[e}%W}}WTBn}}}}}}}}".bytes{|i|$><<(i+?A.ord)%?_.ord}
```
[Try it online!](https://tio.run/##KypNqvz/XykvT9/DtybQKrMsLrLCPzq1VjW8tjY8xCmvFgqU9JIqS1KLq2sya1TsbGw0MrXtHfXyi1I0Ve3jQXTt//8A "Ruby ‚Äì Try It Online")
By coincidence, the range of digit pairs is 0 to 94, which only just fits in the ASCII range. 
`(i+?A.ord)%?_.ord` = `(i+65)%95`. The 65 offset ensures no digit characters in the magic string. 
By default numbers are printed without leading zeros, so digit pairs in the range `00..09` require two characters in the magic string. The other digit pairs require one character.
[Answer]
# Java 8, 86 bytes
```
v->"·æë‰êë·ºä„âå‚ä°Ó®Å‚ñí–¥·≠û·µ∏·™ë".chars().forEach(c->System.out.print(~-c))
```
[Try it online.](https://tio.run/##y0osS9TNSsn@n5yTWFys4JuYmVfNpaCQmVeSWpSWmJyq4AfiKiiU5WemKCRrhIGoMk1roFgtF5AoLkksyUxW8FPIU7D9X6Zrp/Rw38QnEyY@3NP1uLPnUdfCdysaH02bdGHLw7XzHm7d8XDVREYIUNJLzkgsKtbQ1EvLL3JNTM7QSNa1C64sLknN1csvLdErKAK6QKNON1lT8781yKKC0qQcoEVQ@8CuyQW6VSO4BKgyPTpWIVET4tA8vWSNvNKcHKgba/8DAA)
**Explanation:**
```
v->  // Method with empty unused parameter and no return-type
  "·æë‰êë·ºä„âå‚ä°Ó®Å‚ñí–¥·≠û·µ∏·™ë".chars().forEach(c->
     //  Loop over the characters of this string as integer codepoints:
    System.out.print(~-c))
     //   Print this integer - 1 to STDOUT
```
The string contains the characters with the codepoints:
```
8081,17425,7946,12876,8865,59905,9618,1076,7006,7544,6801,1,1,1,1,1,1,1
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 35 bytes
```
'nTIFBCAAAAA@A@A@A@@A'tfYqwIEW-^X$p
```
[Try it online!](https://tio.run/##y00syfn/Xz0vxNPNydkRBBwg0MFRvSQtsrDc0zVcNy5CpeD/fwA "MATL ‚Äì Try It Online")
### Explanation
This uses the prime factorization of the number:
\$ 808017424794512875886459904961710757005754368000000000 \\ = 2^{46} ¬∑ 3^{20} ¬∑ 5^9 ¬∑ 7^6 ¬∑ 11^2 ¬∑ 13^3 ¬∑ 17 ¬∑ 19 ¬∑ 23 ¬∑ 29 ¬∑ 31 ¬∑ 41 ¬∑ 47 ¬∑ 59 ¬∑ 71. \$
```
'nTIFBCAAAAA@A@A@A@@A' % Push this string
t                      % Duplicate
f                      % Indices of nonzero chars: gives [1 2 3 ... 19 20]
Yq                     % n-th prime, element-wise: gives [2 3 5 ... 67 71]
w                      % Swap
IEW                    % Push 3, multiply by 2, exponential with base 2: gives 64
-                      % Subtract, element-wise: subtracts 64 from the code point
                       % of each character of the string. Gives [46 20 9 ... 0 1]
^                      % Element-wise power. Gives [2^46 3^20 5^9 ... 1 71]
X$                     % Convert to symbolic (to achieve arbitrary precision)
p                      % Product. Implicit display 
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~37~~ 30 bytes
```
√ò·∫†i‚±Æ‚ÄútTIFBC‚Äù;‚ÅΩ<(B¬§
¬≥√ÜR·πÅ¬¢≈º¬¢*/‚Ç¨P
```
Encodes the number as a list of exponents to primes, probably could be optimized with cleverer builtins
```
√ò·∫†i‚±Æ‚ÄútTIFBC‚Äù;‚ÅΩ<(B¬§
    ‚ÄútTIFBC‚Äù       the string "tTIFBC"
  i‚±Æ               find indices of each character in
√ò·∫†                 the alphabet in both cases "A..Za..z"
             ‚ÅΩ<( ¬§ the number 16041
                B¬§ converted to binary
            ;      append
```
```
¬≥√ÜR·πÅ¬¢≈º¬¢*/‚Ç¨P
 √ÜR         all primes below
¬≥           100
   ·πÅ        shaped like
    ¬¢       the above line
     ≈º      zipped with
      ¬¢     the above line
       */‚Ç¨  exponent for each pair
          P product
```
-7 bytes by encoding the final 0/1 sequence as binary
[Try it online!](https://tio.run/##ATwAw/9qZWxsef//w5jhuqBp4rGu4oCcdFRJRkJD4oCdO@KBvTwoQsKkCsKzw4ZS4bmBwqLFvMKiKi/igqxQ//8 "Jelly ‚Äì Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~29~~ ~~28~~ 27 bytes
-1 byte thanks to @KevinCruijssen
```
‚Ä¢‚àç√Ω√∂/V$√âb¬¥‚Ä∞≈ír∆∂√úŒªF√Ñ√¥S‚Ä¢¬¶¬æT<√ó¬´
```
[Try it online!](https://tio.run/##ATsAxP9vc2FiaWX//@KAouKIjcO9w7YvViTDiWLCtOKAsMWScsa2w5zOu0bDhMO0U@KAosKmwr5UPMOXwqv//w "05AB1E ‚Äì Try It Online")
---
# [05AB1E](https://github.com/Adriandmen/05AB1E), 21 bytes
Answer suggested by @KevinCruijssen as a port of the Jelly answer by @JonathanAllen
```
‚ÇÜ√çR≈æw≈∏!‚Ä¢P«ù¬ΩŒ∂√Ñ≈æ,ƒÄ‚Ä¢‚ÇÜ–≤*O
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UVPb4d6go/vKj@5QfNSwKOD43EN7z2073HJ0n86RBqAAUP7CJi3///8B "05AB1E ‚Äì Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 91 bytes
```
import Data.Numbers.Primes
product[p^length[';'..c]|(c,p)<-zip"hNC@<=;;;;;:;:;:;::;"primes]
```
[Try it online!](https://tio.run/##NY5Bi8IwGETv/oqPIqioJXWTJrUGBb0IiwgeRaHGYIttEpIUy7L/vVbFN6d5h2HyzN1lWbZtURltPWwyn4W7urpI68K9LSrpeg03Vl9r4Y/mXEp18/lxkA7CUJz@h2JiRovpX2GCfLdeLXj6Yv7JPA3Me@HUVlmh@FX3oKNzykMfmk@r/cHbX9WJYOtAaGul8KDeF5YQwHgMLtcPGDbAOTDEUETxDNMEk2jGKGEsxiRJEE7iiEaIEooQoQT/xAx9GbVP "Haskell ‚Äì Try It Online") (has an extra 2 bytes for `x=`)
Probably suboptimal but I had a lot of fun writing it. I encode the prime exponents (including zeroes for the primes it doesn't have prior to 71) as a string using the character's relative distance from `:`. the rest is a simple matter of zipping the exponents against an infinite list of all primes, raising those primes to that power, and taking the product.
Edit: forgot to take the `x=` out of the source code on here.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~84~~ \$\cdots\$ ~~81~~ 83 bytes
Saved a byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!  
Added 2 bytes to fix a bug kindly pointed out by [gastropner](https://codegolf.stackexchange.com/users/75886/gastropner).
```
*s;f(){for(s=L"nn/HM|Q:iv^YxO[e}%W}}WTBn}}}}}}}}";*s;)printf("%d",(*s+++'A')%'_');}
```
[Try it online!](https://tio.run/##S9ZNT07@/1@r2DpNQ7M6Lb9Io9jWRykvT9/DtybQKrMsLrLCPzq1VjW8tjY8xCmvFgqUrIE6NAuKMvNK0jSUVFOUdDS0irW1tdUd1TVV1ePVNa1r/wPlFHITM/M0NBWquRSAAGiDNVftfwA "C (gcc) ‚Äì Try It Online")
Port of [Level River St](https://codegolf.stackexchange.com/users/15599/level-river-st)'s [Ruby answer](https://codegolf.stackexchange.com/a/203533/9481).
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~27~~ 25 bytes
*Thanks to Underslash for -2 bytes because numbers.*
```
¬ª$‚á©‚à™¬£¬º…æ«è‚ÑÖy·πô`‚ÇÜg«è¬¶¬®Œª¬ªkŒµk√ó**
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C2%BB%24%E2%87%A9%E2%88%AA%C2%A3%C2%BC%C9%BE%C7%8F%E2%84%85y%E1%B9%99%60%E2%82%86g%C7%8F%C2%A6%C2%A8%CE%BB%C2%BBk%CE%B5k%C3%97**&inputs=&header=&footer=)
Unfortunately, the compressed form of the number contains a `2` and a `0`. This is a different number, multiplied by another number multiplied by another number, to get the target number.
```
¬ª$‚á©‚à™¬£¬º…æ«è‚ÑÖy·πô`‚ÇÜg«è¬¶¬®Œª¬ª        # Push 11482618231106483731969943632999939453125
                   kŒµ      # Push 32768
                     k√ó    # 2147483648
                       **  # Multiply all the numbers
                           # Implicit output
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 93 bytes
```
FromDigits[LetterNumber/@Characters@"h h agdbdgideabhgehhfdeii difaga geg  egedcfh         "]
```
[Try it online!](https://tio.run/##NcgxCkJBDAXAq4R/AU8gLChWIvZikd1kX1KsQn48f7RxylmcpovTBxeOdYn3Ojs898dVMzVun9U1Du1kHDx@sbfNyIghXeCi3A1qNkXdSXwymKAgUqiMafS3Pese/kpqqPoC "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Core utilities, 67 bytes
```
tr o-z /-:<<<xpxpqwtrtwytuqrxwuxxvtuyyptyvqwqpwuwppuwutsvxppppppppp
```
[Try it online!](https://tio.run/##NcGxEYAwDAPAVVggR89lGajokBM5slneVPxf57yrOLanvdvejt57IGDioJJuI@QRi54J5jIZ5AJczrkCv6oP "Bash ‚Äì Try It Online")
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 50 bytes
```
prod(primes('G').^sym('hNC@<=;;;;;:;:;:;::;'-':'))
```
[Try it online!](https://tio.run/##y08uSSxL/f@/oCg/RaOgKDM3tVhD3V1dUy@uuDJXQz3Dz9nBxtYaBKwg0MpaXVfdSl1T8/9/AA "Octave ‚Äì Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~183~~ ~~171~~ 170 bytes
```
++++++++[>+++++++>++++++<<-]>.>.<.>.+.<-.---.>+.<.+++.++.>++.+.
----.+.<-.-.>+++.<+..--.>-.+.<+++..>-----.++++.<.---.>---.<+.>.
-.<.--.++.>..<--.++.--.-.-.+++.++.>.........
```
[Try it online!](https://tio.run/##PY1RCoAwDEMPNJITlF5E/FBBEMEPwfPPtKsWuj7SNFvv5bj2Zzt7b1WTF9Q0w@x0mrrRQAB0EbVUizVCRe1DETUynKmGIBym3I6YeGR0HYWScVRIEiIL/zf8qvcX "brainfuck ‚Äì Try It Online")
Linebreaks added for readability so not included in the byte count.
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), ~~82~~, 76 bytes
### *Kudos to @ceilingcat for -6 bytes*
```
void f(){for(auto s:L"ÛÖëëÒß≠öÒΩç´ÛòöªÛúºÅëñ£Ú´Çü∆¥ÛÉîÄ")printf("%i",s);printf("%i%i%i",!f,!f,!f);};
```
[Try it online!](https://tio.run/##Sy4o0E1PTv6vnJmXnFOakmqTXFySkplv978sPzNFIU1Dszotv0gjsbQkX6HYykfpc@vEiR@Xr531cW/v6s8zZu3@PGdP44eJ0xZ/Wt00/9iWz81TGpQ0C4oy80rSNJRUM5V0ijWtEVwQVNJRTIMgTeta6/9AKYXcxMw8kD0aQJH/AA "C++ (gcc) ‚Äì Try It Online")
# [C++ (gcc)](https://gcc.gnu.org/), 82 bytes
```
void f(){for(auto s:L"ÛÖëëÒß≠öÒΩç´ÛòöªÛúºÅëñ£Ú´Çü∆¥ÛÉîÄ")printf("%i",s);printf("%i%i%i",NULL,NULL,NULL);};
```
[Try it online!](https://tio.run/##Sy4o0E1PTv6vnJmXnFOakmqTXFySkplv978sPzNFIU1Dszotv0gjsbQkX6HYykfpc@vEiR@Xr531cW/v6s8zZu3@PGdP44eJ0xZ/Wt00/9iWz81TGpQ0C4oy80rSNJRUM5V0ijWtEVwQVNLxC/XxQRCa1rXW/4EKFHITM/NAtmkARf4DAA "C++ (gcc) ‚Äì Try It Online")
My first ever Code Golf submission! :)
Explanation: The loop part of the function prints a decimal representation for each Unicode character in the string. I was really stumped as to how to print zeros without being allowed to have `0` in the code. I just added `NULL` characters cast to `int`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 14 bytes
```
‚Äú ¬Ω‚Äò!P√ó‚Äú·∏•…óe≈Ä∆ä‚Äô
```
[Try it online!](https://tio.run/##y0rNyan8//9RwxyFQ3sfNcxQDDg8Hch5uGPpyempRxuOdT1qmPn/PwA "Jelly ‚Äì Try It Online")
Just saw alephalpha's answer before edit and thought "what if I port it to Jelly?" and it worked.
Uses the formula from [this comment](https://codegolf.stackexchange.com/questions/60329/the-mystery-string-printer-robbers/60581#comment145791_60581):
> 
> `31!10!27079205916672`
> 
> 
> 
then I noticed that `27079205916672` is a multiple of 32, so I changed the formula to
> 
> `32!10!846225184896`
> 
> 
> 
cutting one more byte from the compressed number.
The Jelly code does "`‚Äú ¬Ω‚Äò` (32, 10) `!P` factorial each and product `√ó` times `‚Äú·∏•…óe≈Ä∆ä‚Äô` 846225184896".
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~79 78~~ 58 bytes
*Saved 20 (!) bytes thanks to @tsh*
A port of [Neil's approach](https://codegolf.stackexchange.com/a/203529/58563).
```
_=>eval(Buffer("?@^ddrtuuuvwxxy{|~~~~»ÄÊéÄ").join`n*`+'n')
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1i61LDFHw6k0LS21SEPJ3iEuJaWopLS0tKy8oqKyuqYOCE40POtrUNLUy8rPzEvI00rQVs9T1/yfnJ9XnJ@TqpeTn66RpqGp@R8A "JavaScript (Node.js) ‚Äì Try It Online")
---
# [JavaScript (Node.js)](https://nodejs.org), 93 bytes
```
_=>eval('ZxEDCCCCBAECEBBBBn*ZxEAAFEEEFECn*ZxFFCn*ZxFDDAAEn*ZxAZZZZZZZZZZn'.replace(/Z/g,+[]))
```
[Try it online!](https://tio.run/##PYhtCoQgFEWXkzV9rKCBlz4XYUSI84pCVCqi3ZsRzPlz7zmrPvVutiUclfM/ilMbx/ZLp7YsUxcKnugAOXYJV6QEIBFRIn9MyneEAMDngfrjsnqjYLUh1qhmLj/9kOfReLd7S7X1M5tYCjc "JavaScript (Node.js) ‚Äì Try It Online")
The idea here was to look for factorizations of \$N\$ with factors whose hexadecimal representation only contains letters and \$0\$'s, so that we only need to replace \$0\$'s with a substitute character.
There are countless possibilities. We use this one: 
```
0xEDCCCCBAECEBBBB * 0xEAAFEEEFEC * 0xFFC * 0xFDDAAE * 0xA0000000000
```
---
# [JavaScript (Node.js)](https://nodejs.org), 101 bytes
```
_=>eval("FxHOOFdNebfLLMHOGdFMcFGKKffKn*In**HFn<<JLn".replace(/[A-Z]/g,c=>c.charCodeAt()%(~[]+[+[]])))
```
[Try it online!](https://tio.run/##DczBCoMgGADgdwkGWqteoIIYWJs27xMZ7ldrQzQsYqe9euv6Hb6P2tQC8T2vuQ/a7Lben3VjNuVQQr4950TfzcsyNvS802QA0lFqLfXp1adpT3xV3ZhPimhmp8CgUrT5Q5bjGeoGCphUvBxtuyJ8Qj8hM5EJKTHGOwS/BGcKF0Zk0QF/ "JavaScript (Node.js) ‚Äì Try It Online")
The encoded expression is:
```
0x2990d8ebf667291d07c0155ff5n*3n**20n<<46n
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 81 bytes
```
v->"XPXPQWTRTWYTUQRXWUXXVTUYYPTYVQWQPWUWPPUWUTSVXPPPPPPPPP".chars().map(n->n-' ')
```
[Try it online!](https://tio.run/##ZY9PT4QwEMXvfIrJXrYYaLyvS@LFxINJWf4UYjxUFthiKaQdMMTsZ8fK6sm5TCbvN/PedGIWYXf@WGU/DgahczOdUCraTLpCOWh6d/D@iRZNLfofqVLCWngRUsOXBzBO70pWYFGga/Mgz9A7jSRopG5f30CY1vobCvD0a/GQOy541phsZyNo4LjOYbQrWMFinp5SXqZZfCp4VhR5mpUlS8s85jHjGWcs41ma5AX7qx2tLsJY4tNejESHkQ73sPfXw2YqNboY9thQMY5qIXpSyqc4PBojFuLfoGSxWPd0mJCOLjgqTXT9CbcviA3uA0tVrVu8@NvG1buu3w "Java (JDK) ‚Äì Try It Online")
If Java's `int` allowed for (much) more than 32 bits, the following (65 bytes) would have worked:
```
v->",--------<?DGLRT\\^hhhpppptv|".chars().reduce(',',(a,b)->a*b)
```
[Answer]
# [K4](https://kx.com/download/), 64 bytes,
**Solution:**
```
,/$.Q.a?"iaiabhecehjefbcihfiigefjjaejgbhbahfhaafhfedgiaaaaaaaaa"
```
**Explanation:**
Really boring, lookup each letter in the alphabet (e.g. "b" => 1), convert to string and flatten
```
    ,/$.Q.a?"iaiabhecehjefbcihfiigefjjaejgbhbahfhaafhfedgiaaaaaaaaa" / solution
            "iaiabhecehjefbcihfiigefjjaejgbhbahfhaafhfedgiaaaaaaaaa" / a -> 0, b -> 1 etc
       .Q.a?                                                         / lookup in built-in alphabet a-z
      $                                                              / convert to string
    ,/                                                               / flatten
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 42 bytes
```
say [*] ¬≤X*'``}}}~~~~~yuuuwr\t|{^;G'.ords
```
[Try it online!](https://tio.run/##K0gtyjH7/784sVIhWitW4dCmCC31hITa2to6EKgsLS0tL4opqamOs3ZX18svSin@r5xQzWUUZ2SsoAWkTLWQaAUuUy0gBAqg0@ZaxkBoRALL0FDL0BBEgwSMsTPMtcyBdhoBuYaWINuNgFpBmkFiQGgJYxkbgljGWiaGEBETc7BbwfLmhly1/wE "Perl 6 ‚Äì Try It Online")
Uses the same strategy of reducing the ordinal values of a string by multiplication as other answers, but also multiplies each element by 2 beforehand to save a byte on representing all those powers of two.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~50~~ 47 bytes
```
p eval (%w(Gv/ R>t. &DhP)*" @QQH}bMA").bytes*?*
```
[Try it online!](https://tio.run/##KypNqvz/v0AhtSwxR0FDtVzDvUxfIciuRE9BzSUjQFNLScEhMNCjNsnXUUlTL6myJLVYy17r/38A "Ruby ‚Äì Try It Online")
Thanks histocrat for -1 byte, ad Jo King for pointing out some silliness in the original answer.
[Answer]
# [Io](http://iolanguage.org/), 79 bytes
```
"·æë‰êë·ºä„âå‚ä°Ó®Å‚ñí–¥·≠û·µ∏·™ë"foreach(i,(-i)bitwiseComplement print)
```
[Try it online!](https://tio.run/##y8z//1/p4b6JTyZMfLin63Fnz6Ouhe9WND6aNunClodr5z3cuuPhqomMEKCUll@UmpicoZGpo6GbqZmUWVKeWZzqnJ9bkJOam5pXolBQlJlXovn/PwA "Io ‚Äì Try It Online")
[Answer]
# [Red](http://www.red-lang.org), ~~88~~ 78 bytes
```
foreach c"XPXPQWTRTWYTUQRXWUXXVTUYYPTYVQWQPWUWPPUWUTSVXPPPPPPPPP"[prin c - sp]
```
[Try it online!](https://tio.run/##NcExDoAgDADArxB2/9JiS9sQBwMYXZTg/1Mn72Zvnnormx/P7Hs9Q40KCiiUSIwYkwqrZmIzIMsoCMICwMK0ZoVfLGNed6hhCe/Y3D8 "Red ‚Äì Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 41 bytes
```
*F^MC,fP_TSC\G+C\.xLG"ujgcdbbbbbabababaab
```
[Try it online!](https://tio.run/##K6gsyfj/X8stztdZJy0gPiTYOcZd2zlGr8LHXak0Kz05JQkEEiEwMen/fwA "Pyth ‚Äì Try It Online")
```
*F^MC,fP_TSC\G+C\.xLG"ujgcdbbbbbabababaab    Implicit: G=lower case alphabet
                   L "ujgcdbbbbbabababaab    For each character in the string...
                  x G                        ... find it's index in the alphabet
              +C\.                           Prepend 46 (character code of .) - these are the prime powers
           C\G                               71
          S                                  Range 1-71
      fP_T                                   Filter keep the primes in the above
     ,                                       Pair the primes with the prime powers
    C                                        Transpose
  ^M                                         Map exponent operator over each pair
*F                                           Take product of the result, implicit print
```
[Answer]
# [Deadfish~](https://github.com/TryItOnline/deadfish-), 164 bytes
```
iiisdo{d}oiiisdo{d}oioisiiiodddoddosoiiioiiodddddoioddddoioisdododdoiiiooddoddoioddsoo{d}oiisodsodddo{d}ioisiiio{d}iodoiisiiioddoiio{d}ooiisioiioddododoiiioii{o{d}}
```
[Try it online!](https://tio.run/##TU0xDsBACHpRH9WENnVicLzc262oTToYQRBwnbjNnyPCzBxc2PwhmicjgBy6JDZP2rtMKcsgme2V6Jw8Z2J5k36ZBfUyDewb69IlCp3KJW1HvA "Deadfish~ ‚Äì Try It Online")
[Answer]
## C (gcc), 77 bytes
```
*s;f(){for(s=L"pp!'JO~S<kx`[zQ]g kf YVDp        ";*s;)printf("%d",*s++-' ');}
```
Assumes that `wchar_t` and `int` have the same size. This way we can make the string wide and we can omit the type when declaring `s`.
A naive approach: group the digits in blocks of 1‚Äì3, each of which is an integer between 0 and 127 with no leading 0. Since character 0 can't be present in the string, characters are encoded as their value plus some constant. The constant is 32, which has the advantage of keeping all characters printable.
### C (gcc), 78 bytes
Bonus: without relying on `wchar_t` and `int` having the same size. We save 1 byte (the `L`) by not having a wide string, but lose 1 byte because the implicit-int declaration `*s` is replaced by the explicit type name `char`.
```
f(){for(char*s="pp!'JO~S<kx`[zQ]g kf YVDp        ";*s;)printf("%d",*s++-' ');}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NQ7M6Lb9IIzkjsUir2FapoEBR3cu/LtgmuyIhuiowNl0hO00hMsylQAEKlKy1iq01C4oy80rSNJRUU5R0tIq1tXXVFdQ1rWv/A0UVchMz80CmaoAEAA "C (gcc) ‚Äì Try It Online")
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 36 bytes
`|.ab*n!?+il"√ò√ò√ò√ò√ò√ò√ï√¨√´√∂√∏√®√∫√∫√¶√≤√∑√µ√Æ√ê√ê√Ñp"`
[Try it online!](https://tio.run/##S8sszvj/v0YvMUkrT9FeOzNH6fAMJDj18JrDqw9vO7zj8IrDu4Bw2eFNh7cf3np43eEJQNhSoPT/PwA)
It's based on a hand-optimized list of partial products of the prime factors of the number, each fitting within a byte.
]