[Question]
  [
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
 
 
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/31695/edit).
Closed 2 years ago.
[Improve this question](/posts/31695/edit) 
Your goal is to print (to the standard output) the largest number possible, using just ten characters of code.
* You may use any features of your language, except built-in exponentiation functions.
	+ Similarly, you may not use scientific notation to enter a number. (Thus, no `9e+99`.)
* The program must print the number without any input from the user. Similarly, no reading from other files, or from the Web, and so on.
* Your program must calculate a single number and print it. You can not print a string, nor can you print the same digit thousands of times.
* You may exclude from the 10-character limit any code necessary to print anything. For example, in Python 2 which uses the `print x` syntax, you can use up to 16 characters for your program.
* The program must actually succeed in the output. If it takes longer than an hour to run on the fastest computer in the world, it's invalid.
* The output may be in any format (so you can print `999`, `5e+100`, etc.)
* [Infinity is an abstract concept](https://en.wikipedia.org/wiki/Infinity), not a number. So it's not a valid output.
  
[Answer]
# Perl, >1.96835797883262e+18
```
time*time
```
Might not be the largest answer... today! But wait enough millennia and it will be!
  
  
---
**Edit:**
To address some of the comments, by "enough millenia," I do in fact mean n100s of years.
To be fair, if the big freeze/heat death of the universe is how the universe will end (estimated to occur ~10100 years), the "final" value would be ~10214, which is certainly much less than some of the other responses (though, "random quantum fluctuations or quantum tunneling can produce another Big Bang in 101056 years"). If we take a more optimistic approach (e.g. a cyclic or multiverse model), then time will go on infinitely, and so some day in some universe, on some high-bit architecture, the answer would exceed some of the others.
On the other hand, as pointed out, `time` is indeed limited by the size of integer/long, so in reality something like `~0` would always produce a larger number than `time` (i.e. the max `time` supported by the architecture).
This wasn't the most serious answer, but I hope you guys enjoyed it!
[Answer]
# Wolfram ‚âÖ 2.003529930 √ó 1019728
Yes, it's a language! It drives the back-end of the popular Wolfram Alpha site. 
It's the only language I found where the Ackermann function is built-in **and** abbreviated to less than 6 characters.
In eight characters:
```
$ ack(4,2)
200352993...719156733
```
Or ‚âÖ 2.003529930 √ó 1019728
`ack(4,3)`, `ack(5,2)` etc. are much larger, but too large. `ack(4,2)` is probably the largest Ackermann number than can be completely calculated in under an hour.
Larger numbers are rendered in symbolic form, e.g.:
```
$ ack(4,3)
2‚Üë¬≤6 - 3 // using Knuth's up-arrow notation
```
The rules say any output format is allowed, so this might be valid. This is greater than 101019727, which is larger than any of the other entries here except for the repeated factorial.
However,
```
$ ack(9,9)
2‚Üë‚Å∑12 - 3
```
is larger than the repeated factorial. The largest number I can get in ten characters is:
```
$ ack(99,99)
2‚Üë‚Åπ‚Å∑102 - 3
```
This is insanely huge, the Universe isn't big enough to represent a significant portion of its digits, even if you took repeated logs of the number.
[Answer]
# Python2 shell, 3,010,301 digits
```
9<<9999999
```
Calculating the length: Python will append a "L" to these long numbers, so it reports 1 character more than the result has digits.
```
>>> len(repr( 9<<9999999 ))
3010302
```
First and last 20 digits:
```
40724177878623601356... ...96980669011241992192
```
[Answer]
# CJam, 2 √ó 10268,435,457
```
A28{_*}*K*
```
This computes *b*, defined as follows:
* a0 = 10
* an = an - 12
* b = 20 √ó a28
```
$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458
```
### Background
This follows the same idea as [Claudiu's answer](https://codegolf.stackexchange.com/a/31718), but it isn't based on it. I had a similar idea which I posted [just a few minutes](https://codegolf.stackexchange.com/revisions/31713/3) after [he posted his](https://codegolf.stackexchange.com/revisions/31718/3), but I discarded it since it didn't come anywhere near the time limit.
However, [aditsu's suggestion](https://codegolf.stackexchange.com/questions/31695/largest-number-in-ten-digits-of-code/31718?noredirect=1#comment66589_31713) to upgrade to Java 8 and [my idea](https://codegolf.stackexchange.com/questions/31695/largest-number-in-ten-digits-of-code/31718?noredirect=1#comment66575_31718) of using powers of 10 allowed CJam to calculate numbers beyond the reach of GolfScript, which seems to be due to some bugs/limitations of Ruby's Bignum.
### How it works
```
A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";
```
---
# CJam, ‚âà 8.1 √ó 101,826,751
```
KK,{)*_*}/
```
Takes less than five minutes on my machine, so there's still room for improvement.
This computes a20, defined as follows:
* a0 = 20
* an = (n √ó an - 1)2
### How it works
```
KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/
```
[Answer]
**Wolfram Language**
```
ack(9!,9!)
```
[Try it online!](http://www.wolframalpha.com/input/?i=ack%289!,9!%29)
$$\text{ack}(9!,9!) = 2 \uparrow^{362878} 362883 - 3$$
Output is in Arrow Notation.
[Answer]
# Any language with short enough constant names, 18 digits approx.
```
99/sin(PI)
```
I would post this as a PHP answer but sadly `M_PI` makes this just a little too long! But PHP yields 8.0839634798317E+17 for this. Basically, it abuses the lack of absolute precision in PI :p
[Answer]
# Python 3, 9\*2^(7\*2^33) > 10^18,100,795,813
# 9\*2^(2^35) > 10^10,343,311,894
Edit: 
My new answer is:
```
9<<(7<<33)
```
Old answer, for posterity:
```
9<<(1<<35)
```
Ten characters exactly.
I am printing the number in hex, and
> 
> You may exclude from the 10-character limit any code necessary to print anything. For example, in Python 2 which uses the print x syntax, you can use up to 16 characters for your program.
> 
> 
> 
Therefore, my actual code is:
```
print(hex(9<<(7<<33)))
```
Proof that it runs in the specified time and generates a number of the specified size:
```
time python bignum.py > bignumoutput.py
real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py
```
My number > 10^(15032385538\*log(16)) > 10^18100795813
3 less hex digits than the above wc printout because of the initial `0x9`.
Python 3 is necessary because in python 2, `7<<33` would be a long, and `<<` doesn't take longs as inputs.
I can't use 9<<(1<<36) instead because:
```
Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError
```
Thus, this is the largest possible number of the form `a<<(b<<cd)` printable on my computer.
In all likelihood, the fastest machine in the world has more memory than I do, so my alternate answer is:
```
9<<(9<<99)
```
9\*2^(9\*2^99) > 10^(1.7172038461\*10^30)
However, my current answer is the largest anyone has submitted, so it's probably good enough. Also, this is all assuming bit-shifting is allowable. It appears to be, from the other answers using it.
[Answer]
# **HTML, 9999999999**
```
9999999999
```
.. nailed it.
[Answer]
# Haskell
Without any tricks:
```
main = print -- Necessary to print anything
    $9999*9999 -- 999890001
```
Arguably without calculating anything:
```
main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
```
Adapting [Niet's answer](https://codegolf.stackexchange.com/questions/31695/largest-number-in-ten-digits-of-code/31711#31711):
```
main = print
    $99/sin pi -- 8.083963479831708e17
```
[Answer]
## Powershell - 1.12947668480335E+42
```
99PB*9E9PB
```
Multiplies 99 Pebibytes times 9,000,000,000 Pebibytes.
[Answer]
# J (`((((((((9)!)!)!)!)!)!)!)!`)
Yeah, that's a lot. `10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))` to be not very exact.
```
!!!!!!!!9x
```
[Answer]
# [K/Kona](https://github.com/kevinlawler/kona): ~~8.977649e261~~ 1.774896e308
```
*/1.6+!170
```
* `!170` creates a vector of numbers from 0 to 169
* `1.6+` adds one to each element of the vector & converts to reals (range is 1.6 to 170.6)
* `*/` multiplies each element of the array together
If Kona supported quad precision, I could do `*/9.+!999` and get around 1e2584. Sadly, it doesn't and I'm capped to double precision.
---
old method
```
*/9.*9+!99
```
* `!99` creates a vector of numbers from 0 to 98
* `9+` adds 9 to each element of the vector (now ranges 9 to 107)
* `9.*` multiplies each element by 9.0 (implicitly converting to reals, so 81.0 through 963.0)
* `*/` multiplies each element of the vector together
[Answer]
# Python - Varies, up to 13916486568675240 (so far)
Not entirely serious but I thought it would be kinda fun.
```
print id(len)*99
```
Out of all the things I tried, `len` was most consistently getting me large ids.
Yielded 13916486568675240 (17 digits) on my computer and 13842722750490216 (also 17 digits) on [this site](http://www.compileonline.com/execute_python_online.php). I suppose it's possible for this to give you as low as 0, but it could also go higher.
[Answer]
# Golfscript, 1e+33,554,432
```
10{.*}25*
```
Computes `10 ^ (2 ^ 25)`, without using exponents, runs in 96 seconds:
```
$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10
real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000
```
It can compute up to `9 ^ (2 ^ 9999)`, if only given enough time, but incrementing the inner exponent by one makes it take ~triple the time, so the one hour limit will be reached pretty soon.
**Explanation**:
Using a previous version with the same idea:
```
8{.*}25*
```
Breaking it down:
```
8         # push 8 to the stack
{...}25*  # run the given block 25 times
```
The stack at the start of each block consists of one number, the current number. This starts off as `8`. Then:
```
.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |
```
So the stack, step by step, looks like this:
```
8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216
```
... etc. Written in math notation the progression is:
```
n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)
```
[Answer]
# [wxMaxima](http://andrejv.github.io/wxmaxima/) ~3x1049,948 (or 108,565,705,514 )
```
999*13511!
```
Output is
```
269146071053904674084357808139[49888 digits]000000000000000000000000000000
```
---
Not sure if it quite fits specs (particularly the output format one), but I can hit even larger:
```
bfloat(99999999!)
```
Output is
```
9.9046265792229937372808210723818b8565705513
```
That's roughly 108,565,705,514 which is *significantly* larger than most of the top answers and was computed in about 2 seconds. The `bfloat` function gives [arbitrary precision](http://maxima.sourceforge.net/docs/intromax/intromax.html).
[Answer]
# Haskell, 4950
Aww man, that's not a lot! 10 characters start after the dollar sign.
```
main=putStr.show$sum[1..99]
```
[Answer]
## Mathematica, 2.174188391646043\*10^20686623745
```
$MaxNumber
```
Ten characters exactly.
[Answer]
# Casio fx-350 ES PLUS, approx. 9.999882753E99
Do calculators count?
![](https://i.stack.imgur.com/0B0tI.jpg)
At `70!` the calculator throws error because apparently it has a number range limit `-1E100 ~ 1E100`
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 1.79769e308 (float64) or 9.99999e6144 (decimal128), 3 bytes
This is the minimum reduction of an empty list:
```
‚åä/‚ç¨
```
`‚åä`‚ÄÉminimum
`/`‚ÄÉreduction
`‚ç¨`‚ÄÉempty list
When reducing an empty list, APL will return the [identity element](https://en.wikipedia.org/wiki/Identity_element) of the function used (if known). For minimum reduction of a system without infinities (e.g. ISO APL, to which Dyalog APL adheres), the identity element for minimum is the largest representable number:
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97f@jni79R71rQJz/aQA "APL (Dyalog Unicode) ‚Äì Try It Online") (IEEE 754 64-bit floating-point)
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qW9CjtgmGRhbmXI862tP@P@rp0n/Uu@Y/kPM/DQA "APL (Dyalog Unicode) ‚Äì Try It Online") (IEEE 754-2008 128-bit decimal floating-point)
[Answer]
# Binary Lambda Calculus, \$ f\_{\omega+2} (2)\$, 9.75 bytes
This program outputs a number larger than Graham's Number while using 78 bits, which is 9.75 bytes, within the 10-byte budget given to me:
```
010101000001110011101000000101011000000101101101011010000110100000011100111010
```
If you prefer an ASCII display of the binary number, here it is:
```
TÔøΩÔøΩmhh:
```
(Inspired, but not copied, by the entry mentioned [here](https://codegolf.stackexchange.com/questions/83873/theoretically-output-grahams-number))
## How it works:
This Binary Lambda Calculus expression encodes the following expression below:
```
(\f x.f (f x))(\f n.n (\g m.m g m) f n)(\x.x x)(\f x.f (f x))
```
This Lambda Calculus expression uses [Church Numerals](https://en.wikipedia.org/wiki/Church_encoding#Church_numerals). Church Numerals are generally considered to be the standard representation of natural numbers. What makes Church Numerals powerful is that they are defined using recursion:
`[n] f m = f (f (f (...(f m)...)))` with n f's.
What this means is that if we have a function \$f\$ and a natural number \$n\$, we can simply concatenate them into \$n f\$ to make a much faster function. You can read the article I linked above if you want to see how Church Numerals can be encoded in Lambda Calculus.
### Exponentiation
What is more, Church Numerals can even act on themselves! `n m` represents \$m^n\$ using exponentiation!
Example: \$2^3\$
  
(Here, we will apply that to the function f n, to show the true power of recursion)
* `3 2 f n`
* `2 (2 (2 f)) n`
* `(2 (2 f)) ((2 (2 f)) n)`
* `(2 f) ((2 f) ((2 f) ((2 f) n)))`
* `f (f (f (f (f (f (f (f n)))))))`
* `= 8 f n`
We can create a function that captures the true power of exponentiation!
```
\x.x x
```
When applied to a Church Numeral \$n\$, it returns \$n^n\$. Viola! Let's call our exponential combinator \$E\$, such that:
```
E = (\x.x x)
```
### Recursion
In order to get beyond exponentiation, we must recurse our \$E\$ combinator. Remember how popping a number before a function recurses it? Well, we can do this with the E combinator, provided that it is a unary function. Define the \$R\$ combinator as followed:
```
R = (\g. \m.m g m)
```
Here, how it works is that for a function \$f\$ applied to an number \$n\$, \$Rfn\$ reduces down to \$nfn\$. This is awesome, because Church numerals naturally recurse functions, meaning \$nfn\$ reduces down to \$f (f (f ...(f n)...))\$.
What if we let our function be our exponential combinator \$E\$? \$REn\$ grows tetrationally. But there is no reason to stop here. We can merge \$R\$ and \$E\$ into a single combinator, \$(RE)\$, and recurse that to have \$R(RE)n\$. This grows pentationally.
We can have \$R(R(RE))n\$, \$R(R(R(RE)))n\$, and so on. But notice how the \$R\$ combinator is being recursed over \$E\$. Well, this is where Church Numeral Recursion comes back into play.
### Super-Recursion
Define a new combinator, \$S\$, as the following:
```
S = (\f n.n R f n) = (\f n.n (\g m.m g m) f n)
```
Cool, now one thing that makes this powerful is that while the \$R\$ combinator recurses over a function \$f\$, the \$S\$ combinator repeatedly applies the \$R\$ combinator to a function \$f\$. Consider this:
$$SE3$$
The first thing that \$S\$ combinator is going to do is to reduce to \$nR\$ where n is the number after the \$E\$. So our reduction will look like this:
$$3RE3$$
The Church Numeral recursion applies on \$R\$ over \$E\$, thus nesting \$R\$ three times, thus giving us this:
$$R(R(RE))3$$
As we seen above, each \$R\$ increases the size of the number considerably, and now the \$S\$ combinator recurses over the \$R\$ combinator! The combinator (SE) grows at \$f\_{\omega}\$ in the Fast Growing Hierarchy, about the limit of the Ackermann Function. We can take this a step forward.
* \$R(SE)\$ recurses over the (SE) combinator, growth rate similar to Graham's Number
* \$R(R(SE))\$ has \$f\_{\omega+2}\$ growth in the fast growing hierarchy
* \$S(SE)\$ has \$f\_{\omega2}\$ growth in the fast growing hierarchy
* \$S(S(SE))\$ has \$f\_{\omega3}\$ growth in the fast growing hierarchy
Similar to how inserting a church numeral before \$R\$ can recurse the recursion function over \$E\$, inserting a church numeral before \$S\$ recurse the super-recursion function over \$E\$. For example, \$2SE\$ = \$S(SE)\$.
## The Number:
The number is \$2SE2\$ using Church Numerals and the combinators defined above. This translates to about \$f\_{\omega+2} (2)\$ in the Fast Growing Hierarchy, which is greater than Graham's Number. Graham's Number is far greater than even \$Ack(9!,9!)\$ in Wolfram-Alpha. Expanding \$2SE2\$ will yield:
```
(\f x.f (f x))(\f n.n (\g m.m g m) f n)(\x.x x)(\f x.f (f x))
```
The lambda expression for \$2\$ is `(\f x.f (f x))`, as you can see it is a Church Numeral. By decoding this Lambda Calculus Expression in [Binary Lambda Calculus](https://esolangs.org/wiki/Binary_lambda_calculus), one could expect a 9.75-byte expression:
```
010101000001110011101000000101011000000101101101011010000110100000011100111010
```
We proved that we can beat Graham's Number in 10 bytes! Ridiculous?
[Answer]
# Python shell, 649539 999890001
Beats Haskell, not really a serious answer.
```
99999*9999
```
[Answer]
I'd rather post this as a comment above, but apparently I can't since I'm a noob.
Python:
`9<<(2<<29)`
I'd go with a larger bit shift, but Python seems to want the right operand of a shift to be a non-long integer. I think this gets closer to the theoretical max:
`9<<(7<<27)`
The only problem with these is that they might not satisfy rule 5.
[Answer]
## Befunge-93 (1,853,020,188,851,841)
Glad nobody has done Befunge yet (it's my niche), but dammit I can't find any clever trick to increase the number.
```
9:*:*:*:*.
```
So it's 9^16.
```
:*
```
Basically multiplies the value at the top of the stack with itself. So, value at the top of the stack goes:
```
9
81
6561
43046721
1853020188851841
```
and
```
.
```
Outputs the final value.
I would be interested to see if anybody has any better ideas.
[Answer]
## At least Python 3.5.0 (64-bit), more than 10^242944768872896860
```
print("{:x}".format( 9<<(7<<60) ))
```
In an ideal world, this would be `9<<(1<<63)-1`, but there aren't enough bytes for that. This number is so big that it requires almost 1 EiB of memory to hold it, which is a little bit more than I have on my computer. Luckily, you only need to use around 0.2% of the world's storage space as swap to hold it. The value in binary is `1001` followed by 8070450532247928832 zeros.
If Python comes out for 128-bit machines, the maximum would be `9<<(9<<99)`, which requires less than 1 MiYiB of memory. This is good, because you'd have enough addressable space left to store the Python interpreter and the operating system.
[Answer]
# Matlab (1.7977e+308)
Matlab stores the value of the largest (double-precision) floating-point number in a variable called `realmax`. Invoking it in the command window (or at the command line) prints its value:
```
>> realmax
ans =
  1.7977e+308
```
[Answer]
# Python, ca. 1.26e1388
```
9<<(9<<9L)
```
Gives:
> 
> 126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L
> 
> 
> 
[Answer]
# Perl, non competing
I'm using this to highlight a little know corner of perl.
Perl can't really compete on this one because it doesn't have builtin bignums (of course you could load a bignum library).
But what everybody knows isn't completely true. One core function actually can handle big numbers.
The `pack` format `w` can actually convert any size natural number between base `10` and base `128`. The base 128 integer is however represented as string bytes. The bitstring `xxxxxxxyyyyyyyzzzzzzz` become the bytes: `1xxxxxxx 1yyyyyyy 0zzzzzzz` (every byte starts with 1 except the last one). And you can convert such a string to base 10 with unpack. So you can write code like:
```
unpack w,~A x 4**4 .A
```
which gives:
```
17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425
```
You can replace the `4**4` by larger values until you feel it takes too long or uses too much memory.
Unfortunately this is way too long for the limit of this challenge, and you can argue that the base 10 result is converted to a string before it becomes the result so the expression doesn't really produce a number. But internally perl really does the needed arithmetic to convert the input to base 10 which I always considered rather neat.
[Answer]
# TI-36 (not 84, 36), 10 bytes, approx. 9.999985426E99
Older calculators can be programmed to an extent as well ;)  
  
`69!58.4376`  
  
This is very close to the maximum range a TI calculator can display: `-1E100<x<1E100`  
  
[![enter image description here](https://i.stack.imgur.com/FaFPp.jpg)](https://i.stack.imgur.com/FaFPp.jpg)
[Answer]
## [><>](http://esolangs.org/wiki/Fish)
**2020 update:**
`'*:*l1=?n!`
[Try it online!](https://tio.run/##S8sszvj/X13LSivH0NY@T/H/fwA)
A nice, big number.
6607775919524790651439701166707789489378797865523309469653600804966653717124420234900643695716633983263105744751733811265946551350757473520290996592227365993351117075631863250858664418726460620430636874466736708735091515674858617262672061392356105274688381926671523379031815127376998794734801639561117309008230181917173237247958670364395979998445068443549603086925428413456037483510188036968643022754136876546302694036337733250775972540791054488317803988268522700511802405629821189614545680714572177873101991977461377780062066275613653646526353437038254323542049537486740164431723433218814788820554530926749282165106713414138827765731299184793201063834591836604608194080942136186867241173559749340134123556348756219648917627921044482452298279885527390296021299809895208344965720017693561708427752229404713795765501476321809083160697802384075712539404128882728723305116462257211512254983151160419880169748505483542215949682009001146040637299350914438311533945478015790682139849329365319957805121129755402607972548916020445921204515251014341335241310585757251648664383763145215969276240907124147926204015695626240000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
---
## ~~3147440830160257032480100000000~~ 319626579315078487616775634918212890625
**Edit:**
Seems like I am allowed to exclude the characters needed for printing, the `n` in this case, so here is an updated version:
```
':*:*:*:*n√ø
```
**Original answer:**
```
'*:*:*:*n;
```
Here, `'` activates stringmode, and pushes all the following characters to the stack, before wrapping and exiting stringmode. Then it does a multiply-and-copy chain, printing the number, and exits. Of interest here is the ascii value of `n` 110, and `;` 59.
However, if we allow it to terminate with an error, we can abuse the fact that the official interpreter supports Unicode. The title of the question says bytes, but the text says characters, so the following program is just for the fun of it.
```
'*:*:*:*nüøø
```
Outputting 1867215243681462552708446358738678532523702556144100000000
Alternatively, to stick to bytes, `√ø` at the end gives us 383233022803952503175039062500000000, and that is still nice.
(New "for fun" program `':*:*:*:*nüøø` prints 7587624076546380447593767884781979512738274729546264306618287972087303430335365121)
[Answer]
# ARM Thumb, multiword integer, ~~~1.157921e+77~~ ~4.973232e+86
Machine code:
```
2306 1fd9 000a b407 b407
```
Assembly
```
        .globl main
        .thumb
        .thumb_func
main:
        push    {r4, lr}
        // start number generation code
        movs    r3, #6             // 2
        subs    r1, r3, #7         // 4
        movs    r2, r1             // 6
        push    {r1, r2, r3}       // 8
        push    {r1, r2, r3}       // 10
        // end number generation code
        // now printf everything
        adr     r0, .Lprintf_str
        bl      printf
        pop     {r1, r2, r3}
        pop     {r1, r2, r3, r4, pc}
        // print 32 bits at a time
.Lprintf_str:
        .asciz "%#08x%08x%08x%08x%08x%08x%08x%08x%08x\n"
```
[Try it online! (sorta)](https://travis-ci.com/github/easyaspi314/easyaspi-ppcg/jobs/471966547#L435)
Assembles a 288-bit big endian unsigned integer (with little endian words) with the high 96 bits in `r1-r3` and the low 192 bits on the stack.
The number is, in hex, `0xffffffffffffffff00000006ffffffffffffffff00000006ffffffffffffffff00000006`, or in base 10, `497323236409786642128422301523609912453495901056838330362914156057471888398396751347718`.
# Explanation
You may be wondering why I chose `6` and `7`. The reason is because of the limitations of narrow instructions.
[`movs Rd, #imm` can only encode an 8-bit immediate from `0-255`](https://www.keil.com/support/man/docs/armasm/armasm_dom1361289878994.htm). No negatives allowed, which would make this almost *too* easy.
[`subs Rd, Rn, #imm` can only encode a 3-bit immediate from `0-7`](https://www.keil.com/support/man/docs/armasm/armasm_dom1361289908389.htm). I can only subtract `0-255` if I use the same destination register, which isn't very helpful.
So therefore, since `r1` will be more significant, we put `6` in `r3`, then subtract `7` to get `-1`, or `0xFFFFFFFF`, in `r1`.
```
        movs    r3, #6             // 2
        subs    r1, r3, #7         // 4
```
Now, time for things to get super dumb.
First, we duplicate `0xFFFFFFFF` to `r2` using `movs`.
```
        movs    r2, r1             // 6
```
Then, we (ab)use ARM's `push` instruction. ARM's `push` instruction (as well as its sibling `stm`) can push multiple registers at once to the stack, effectively doing a block copy.
We abuse this to copy `r1`, `r2`, and `r3` to the stack twice, tripling the width of the integer.
You could say this is some form of exponentiation, but all I'm doing is pushing to the stack. Nothing suspicious here. üòá
```
        push    {r1, r2, r3}       // 8
        push    {r1, r2, r3}       // 10
```
Now, it looks like this:
```
   r1: 0xFFFFFFFF    r2: 0xFFFFFFFF
   r3: 0x00000006
 sp+0: 0xFFFFFFFF  sp+4: 0xFFFFFFFF
 sp+8: 0x00000006 sp+12: 0xFFFFFFFF
sp+16: 0xFFFFFFFF sp+20: 0x00000006
```
# ARM Thumb-2, softfloat, 1.797693e+308
Machine code:
```
f248 0310 041b 17da 43db
```
Assembly:
```
        .thumb
        .globl main
        .thumb_func
main:
        push    {r4, lr}
        // Begin number generation code
        movw    r3, #0x8010     // 4
        lsls    r3, r3, #16     // 6
        asrs    r2, r3, #31     // 8
        mvns    r3, r3          // 10
        // End number generation code
        adr     r0, .printf_str
        bl      printf
        pop     {r4, pc}
        .align 4
.printf_str:
        .asciz "%f\n"
```
[Try it online! (sorta)](https://travis-ci.com/github/easyaspi314/easyaspi-ppcg/jobs/471966548#L421)
Creates the 64-bit constant `0x7fefffffffffffff`, which is `DBL_MAX`, in `r2-r3` (since the AAPCS aligns 64-bit integers to even registers)
Specifically, `179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000`
We do this by first putting `~(*(long long*)&DBL_MAX) >> 48` in `r3`, shifting left by 16, doing an arithmetic shift right into `r2` to make it `0xFFFFFFFF`, then do a one's complement to get `r3` to `0x7fefffff`.
# ARM Thumb-2, (non-competing), softfloat + printf merging, 2.148532e+319
Machine code:
```
f248 0110 0409 43ca 0013
```
Assembly:
```
        .thumb
        .globl main
        .thumb_func
main:
        push    {r4, lr}
        // Begin number generation code
        movw    r1, #0x8010     // 4
        lsls    r1, r1, #16     // 6
        mvns    r2, r1          // 8
        movs    r3, r2          // 10
        // End number generation code
        adr     r0, .printf_str
        bl      printf
        pop     {r4, pc}
        // Combine 0x80100000u (2148532224) with the same double we had before.
.printf_str:
        .asciz "%u%f\n"
```
[Try it online! (sorta)](https://travis-ci.com/github/easyaspi314/easyaspi-ppcg/jobs/471967696#L424)
This is obviously cheating, as it is actually generating an unsigned integer and a double and printing them together, but decided to add it for the lulz. üòÇ
It basically does this:
```
uint32_t r1 = (~0x7fef) & 0xffff;
// 0x80100000
r1 <<= 16;
uint32_t r2 = ~r1;
uint32_t r3 = r2;
// 0x7fefffff7fefffff
uint64_t r2r3 = r2 | ((uint64_t)r3 << 32);
double d = *(double*)&r2r3;
printf("%u%f\n", r1, d);
```
]