Ruby, 34 bytes

p 0x1A1285B85F75ECA*1440**9*637**3

Try it online!

Ruby, 35 bytes

p 117419438843059914*1440**9*637**3

Try it online!

Improved my previous answer by almost a factor of 2 with this simple cube factorization. 637=7*7*13 and the big number is divisible by 2*3*3 but most of the small factors are dealt with by

(1440 = 32 * 9 * 5)**9 = 26623333280885243904000000000

tinylisp, 127 bytes

(d T(q((x)(i x(c(s(h x)(h(chars(q !))))(T(t x)))(
(disp(string(T(chars(q YQYQRXUSUXZUVRSYXVYYWUVZZQUZWRXRQXVXQQVXVUTWYQQQQQQQQQ

Try it online!

MathGolf, 18 bytes

8462NG4896]y♂!♥!**

Try it online.

Explanation:

8462NG4896    # Push the integers 8,4,6,2,25,18,4,8,9,6
          ]   # Wrap the stack into a list
           y  # Join it together, and implicitly convert it to an integer: 846225184896
♂!            # Push 10!: 3628800
♥!            # Push 32!: 263130836933693530167218012160000000
**            # Multiply all three values on the stack together
              # (after which the entire stack is output implicitly as result)

PARI/GP, 60 bytes

print(vecprod(Vec(Vecsmall("$$$G^ddhhhprstvwxxxxy{|~~~~"))))

Attempt This Online!

Takes the product of the ASCII codes of the characters.

Here is the Mathematica code to find the string "$$$G^ddhhhprstvwxxxxy{|~~~~".

Jelly, 14 bytes

“ ½‘!PדḥɗeŀƊ’

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:

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".

C#, 61 bytes

_=>"ᾐ䐐Ἁ㉋⊠░г᭝ᵷ᪐␀␀␀␀␀␀␀".Select(x=>+x+"")

Try it online!

Converts a series of characters to their codepoints and then converts that to a string:

ᾐ  8080
䐐  17424
Ἁ  7945
㉋  12875
⊠  8864
  59904
░  9617
г  1075
᭝  7005
ᵷ  7543
᪐  6800
␀  0

␀ here is a null byte (U+0000)

Vyxal, ²⁷ 25 bytes

Thanks to Underslash for -2 bytes because numbers.

»$⇩∪£¼ɾǏ℅yṙ`₆gǏ¦¨λ»kεk×**

Try it Online!

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

Python 2, 61 bytes

Port of Neil's answer.

-5 bytes thanks to @Surclose Sputum!

for i in"  @@G^dddrstuuuvwxxy{|~~~~~":True*=ord(i)
print True

Try it online!

Python 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!

BRASCA, 72 66 bytes

`B:B:;A><>AC>?;<BA?BB@>?CC:>C@;A;:A?A::?A?>=@B:::::::::`![al-mA{]x

Try it online!

Explanation

`B:B:;A><>AC>?;<BA?BB@>?CC:>C@;A;:A?A::?A?>=@B:::::::::`            - Push the number, with the ASCII code shifted by 10
                                                        ![a  mA{]x  - Foreach in stack:
                                                           l-       -    Subtract 10 from the charcode
                                                                    - Implicitly output it

C (gcc), ^{84 \$\cdots\$ 81} 83 bytes

Saved a byte thanks to ceilingcat!!!
Added 2 bytes to fix a bug kindly pointed out by gastropner.

*s;f(){for(s=L"nn/HM|Q:iv^YxO[e}%W}}WTBn}}}}}}}}";*s;)printf("%d",(*s+++'A')%'_');}

Try it online!

Port of Level River St's Ruby answer.

><>, 36 bytes

|.ab*n!?+il"ØØØØØØÕìëöøèúúæò÷õîÐÐÄp"

Try it online!

It's based on a hand-optimized list of partial products of the prime factors of the number, each fitting within a byte.

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!

Charcoal, 32 29 bytes

ＩΠＥ/Gdddrstuuuvwxxy{|~~~~~⊗℅ι

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! Link is to verbose version of code.

Deadfish~, 164 bytes

iiisdo{d}oiiisdo{d}oioisiiiodddoddosoiiioiiodddddoioddddoioisdododdoiiiooddoddoioddsoo{d}oiisodsodddo{d}ioisiiio{d}iodoiisiiioddoiio{d}ooiisioiioddododoiiioii{o{d}}

Try it online!

Pyth, 41 bytes

*F^MC,fP_TSC\G+C\.xLG"ujgcdbbbbbabababaab

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

Ruby, 50 47 bytes

p eval (%w(Gv/ R>t. &DhP)*" @QQH}bMA").bytes*?*

Try it online!

Thanks histocrat for -1 byte, ad Jo King for pointing out some silliness in the original answer.

Haskell, 91 bytes

import Data.Numbers.Primes
product[p^length[';'..c]|(c,p)<-zip"hNC@<=;;;;;:;:;:;::;"primes]

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.

C++ (gcc), ₈₂, 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!

C++ (gcc), 82 bytes

void f(){for(auto s:L"󅑑񧭚񽍫󘚻󜼁𑖣򫂟ƴ󃔀")printf("%i",s);printf("%i%i%i",NULL,NULL,NULL);};

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.

R, 99 bytes

cat(match(strsplit("iaiareyhjefmihfiigefjjaejgrkhfhaafhfedgiaaaaaaaaa","")[[T]],letters)-T,sep="")

Fairly simple zero-based mapping from digits to letters, and using T as a substitute for 1.

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.

brainfuck, 183 171 170 bytes

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

Try it online!

Linebreaks added for readability so not included in the byte count.

Perl 6, 42 bytes

say [*] ²X*'``}}}~~~~~yuuuwr\t|{^;G'.ords

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.

Javascript, 93 characters

_=>'ÉÉŠ£¨×¬•Äѹ´Óª¶ÀyÄ¿y~Ĥ½yyyyyyyyy'.split``.map(c=>c.charCodeAt()-'y'.charCodeAt``).join``

The function returns "808017424794512875886459904961710757005754368000000000".

Explanation: Each character in the string is encoding two characters in the target. Because low character codes are a mess, we offset them by 121 ("y"). I also had to pad some extra 0s (y's) into the string because for instance a "y" and "yy" both convert to "0".

Port of Kevin Crujissen's answer (63 characters):

v=>"ᾑ䐑Ἂ㉌⊡▒д᭞ᵸ᪑".split``.map(c=>~-c.charCodeAt()).join``

K4, 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

Red, 88 78 bytes

foreach c"XPXPQWTRTWYTUQRXWUXXVTUYYPTYVQWQPWUWPPUWUTSVXPPPPPPPPP"[prin c - sp]

Try it online!

Java (JDK), 81 bytes

v->"XPXPQWTRTWYTUQRXWUXXVTUYYPTYVQWQPWUWPPUWUTSVXPPPPPPPPP".chars().map(n->n-' ')

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)

MATL, 35 bytes

'nTIFBCAAAAA@A@A@A@@A'tfYqwIEW-^X$p

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 

Io, 79 bytes

"ᾑ䐑Ἂ㉌⊡▒д᭞ᵸ᪑






"foreach(i,(-i)bitwiseComplement print)

Try it online!

JavaScript (Node.js),  79 78  58 bytes

Saved 20 (!) bytes thanks to @tsh

A port of Neil's approach.

_=>eval(Buffer("?@^ddrtuuuvwxxy{|~~~~Ȁ掀").join`n*`+'n')

Try it online!

JavaScript (Node.js), 93 bytes

_=>eval('ZxEDCCCCBAECEBBBBn*ZxEAAFEEEFECn*ZxFFCn*ZxFDDAAEn*ZxAZZZZZZZZZZn'.replace(/Z/g,+[]))

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), 101 bytes

_=>eval("FxHOOFdNebfLLMHOGdFMcFGKKffKn*In**HFn<<JLn".replace(/[A-Z]/g,c=>c.charCodeAt()%(~[]+[+[]])))

Try it online!

The encoded expression is:

0x2990d8ebf667291d07c0155ff5n*3n**20n<<46n

Wolfram Language (Mathematica), 34 32 bytes

Thanks @my pronoun is monicareinstate for shaving 2 bytes!

Someone has to do this...

Print@GroupOrder@MonsterGroupM[]

Try it online!

Octave, 50 bytes

prod(primes('G').^sym('hNC@<=;;;;;:;:;:;::;'-':'))

Try it online!

Java 8, 86 bytes

v->"ᾑ䐑Ἂ㉌⊡▒д᭞ᵸ᪑".chars().forEach(c->System.out.print(~-c))

Try it online.

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

05AB1E, 29 28 27 bytes

-1 byte thanks to @KevinCruijssen

•∍ýö/V$Éb´‰ŒrƶÜλFÄôS•¦¾T<׫

Try it online!

05AB1E, 21 bytes

Answer suggested by @KevinCruijssen as a port of the Jelly answer by @JonathanAllen

₆ÍRžwŸ!•Pǝ½ζÄž,Ā•₆в*O

Try it online!

Bash + Core utilities, 67 bytes

tr o-z /-:<<<xpxpqwtrtwytuqrxwuxxvtuyyptyvqwqpwuwppuwutsvxppppppppp

Try it online!

Wolfram Language (Mathematica), 93 bytes

FromDigits[LetterNumber/@Characters@"h h agdbdgideabhgehhfdeii difaga geg  egedcfh         "]

Try it online!

Jelly, 21 bytes

⁴Ḥ®x“ÆÑ¥©µ"µ£€× œ‘;Æ¡

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ẏẏż’

Ruby, 67 bytes

"nn/HM|Q:iv^YxO[e}%W}}WTBn}}}}}}}}".bytes{|i|$><<(i+?A.ord)%?_.ord}

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.

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!