[Question]
  [
Your goal is to write a program that prints a number. The bigger the number, the more points you'll get. But be careful! Code length is both limited and heavily weighted in the scoring function. Your printed number will be divided by the **cube of the number of bytes you used for your solution**.
So, let's say you printed `10000000` and your code is `100` bytes long. Your final score will be \$\frac {10000000} {100^3} = 10\$.
There are other rules to follow, in order to make this challenge a bit harder.
* You cannot use digits in your code (0123456789);
* You **can** use mathematical/physical/etc. constants, **but** only if they are less than 10. (e.g. You can use \$\pi \approx 3.14\$ but you can't use the **Avogadro constant** \$= 6\times 10^{23}\$)
* Recursion is allowed **but** the generated number needs to be finite (so **infinite** is not accepted as a solution. Your program needs to terminate correctly, assuming unbounded time and memory, and generate the requested output);
* You cannot use the operations `*` (multiply), `/` (divide), `^` (power) nor any other way to indicate them (e.g. `2 div 2` is not allowed);
* Your program **can output more than one number, if you need it to do that**. Only the highest one will count for scoring;
* However, you **can** concatenate strings: this means that any sequence of adjacent digits will be considered as a single number;
* Your code will be run as-is. This means that the end-user cannot edit any line of code, nor he can input a number or anything else;
* Maximum code length is 100 bytes.
---
### Leaderboard
1. [*Steven H.*, Pyth](https://codegolf.stackexchange.com/a/149781) \$\approx f\_{\varphi(1,0,0)+7}(256^{26})\$
2. [*Simply Beautiful Art*, Ruby](https://codegolf.stackexchange.com/a/149763) \$\approx f\_{\varphi(1,0,0)}(3)\$
3. [*Peter Taylor*, GolfScript](https://codegolf.stackexchange.com/questions/18028/largest-number-printable/18954#18954) \$\approx f\_{\varepsilon\_0+\omega+1}(17)\$
4. [*r.e.s.*, GolfScript](https://codegolf.stackexchange.com/a/18920/58880) \$\approx f\_{\epsilon\_0}^9(126)\approx f\_{\epsilon\_0+1}(9)\$ [1]
5. [*Simply Beautiful Art*, Ruby](https://codegolf.stackexchange.com/a/120228/58880) \$\approx f\_{\omega^{\omega2}+1}(126^22^{126})\$
6. [*eaglgenes101*, Julia](https://codegolf.stackexchange.com/a/146791) \$\approx f\_{\omega^3}(127)\$
7. [*col6y*, Python 3,](https://codegolf.stackexchange.com/a/18359/2183) \$\approx 127\to126\to\dots\to2\to1\approx f\_{\omega^2}(127)\$ [1][3]
8. [*Toeofdoom*, Haskell,](https://codegolf.stackexchange.com/a/18169/2183) \$\approx a\_{20}(1)\approx f\_{\omega+1}(18)\$ [1]
9. [*Fraxtil*, dc,](https://codegolf.stackexchange.com/a/18153/2183) \$\approx 15\uparrow^{166665}15\$ [3]
10. [*Magenta*, Python,](https://codegolf.stackexchange.com/a/79694/58880) \$\approx\mathrm{ack}(126,126)\approx10\uparrow^{124}129\$
11. [*Kendall Frey*, ECMAScript 6,](https://codegolf.stackexchange.com/a/18075/2183) \$\approx1000\uparrow^43\$ [1]
12. [*Ilmari Karonen*, GolfScript,](https://codegolf.stackexchange.com/a/18064/2183) \$\approx10\uparrow^310^{377}\$ [1]
13. [*Aiden4*, Rust,](https://codegolf.stackexchange.com/a/214246/58880) \$\approx10\uparrow^3127\$
14. [*BlackCap*, Haskell,](https://codegolf.stackexchange.com/a/121675/58880) \$\approx10\uparrow\uparrow65503\$
15. [*recursive*, Python,](https://codegolf.stackexchange.com/a/18092/2183) \$\approx2\uparrow\uparrow11\approx10\uparrow\uparrow8.63297\$ [1][3]
16. [*n.m.*, Haskell,](https://codegolf.stackexchange.com/a/18134/2183) \$\approx2\uparrow\uparrow7\approx10\uparrow\uparrow4.63297\$ [1]
17. [*David Yaw*, C,](https://codegolf.stackexchange.com/a/18060/2183) \$\approx10^{10^{4\times10^{22}}}\approx10\uparrow\uparrow4.11821\$ [2]
18. [*primo*, Perl,](https://codegolf.stackexchange.com/a/18058/2183) \$\approx10^{(12750684161!)^{5\times2^{27}}}\approx10\uparrow\uparrow4.11369\$
19. [*Art*, C,](https://codegolf.stackexchange.com/a/18196/2183) \$\approx10^{10^{2\times10^6}}\approx10\uparrow\uparrow3.80587\$
20. [*Robert Sørlie*, x86,](https://codegolf.stackexchange.com/a/18253/2183) \$\approx10^{2^{2^{19}+32}}\approx10\uparrow\uparrow3.71585\$
21. [*Tobia*, APL,](https://codegolf.stackexchange.com/a/18033/2183) \$\approx10^{10^{353}}\approx10\uparrow\uparrow3.40616\$
22. [*Darren Stone*, C,](https://codegolf.stackexchange.com/a/18029/2183) \$\approx10^{10^{97.61735}}\approx10\uparrow\uparrow3.29875\$
23. [*ecksemmess*, C,](https://codegolf.stackexchange.com/a/18049/2183) \$\approx10^{2^{320}}\approx10\uparrow\uparrow3.29749\$
24. [*Adam Speight*, vb.net,](https://codegolf.stackexchange.com/a/18182/2183) \$\approx10^{5000\times2^{256}}\approx10\uparrow\uparrow3.28039\$
25. [*Joshua*, bash,](https://codegolf.stackexchange.com/a/18085/2183) \$\approx10^{10^{15}}\approx10\uparrow\uparrow3.07282\$
**Footnotes**
1. If every electron in the universe were a qubit, and every superposition thereof could be gainfully used to store information (which, as long as you don't actually need to *know* what's being stored is theoretically possible), this program requires more memory than could possibly exist, and therefore cannot be run - now, or at any conceiveable point in the future. If the author intended to print a value larger than ≈10↑↑3.26 all at once, this condition applies.
2. This program requires more memory than currently exists, but not so much that it couldn't theoretically be stored on a meager number of qubits, and therefore a computer may one day exist which could run this program.
3. All interpreters currently available issue a runtime error, or the program otherwise fails to execute as the author intended.
4. Running this program will cause irreparable damage to your system.
---
**Edit** [@primo](https://codegolf.stackexchange.com/users/4098/primo): I've updated a portion of the scoreboard using a hopefully easier to compare notation, with decimals to denote the logarithmic distance to the next higher power. For example \$10↑↑2.5 = 10^{10^{\sqrt {10}}}\$. I've also changed some scores if I believed to user's analysis to be faulty, feel free to dispute any of these.
Explanation of this notation:
If \$0 \le b \lt 1\$, then \$a \uparrow\uparrow b = a^b\$.
If \$b \ge 1\$, then \$a \uparrow\uparrow b = a^{a \uparrow\uparrow (b-1)}\$.
If \$b \lt 0\$, then \$a \uparrow\uparrow b = \log\_a(a \uparrow\uparrow (b+1))\$
An [implementation](https://tio.run/##7Rtpb9s29Lt@BSNgqOXaruX0NOwARbsABbb2w9JiWNEYckw7AmTJk@QcC/Lbs8dDEkmRknwE8NbkQ2FRj@@@@KiubtPLKDx@sG3b@hCFqeeHCfLQii4jf7kK8BLDcurDYzRHKU5j9jDDF/7SC5KONcNzP8QzNL1F6SVG8ygIoms/XMCveLkOvGRoIfjz0Pk5mqIx@YGmHST/@XPUR6MxAIyQW4Zv0afWFHWR6zgdCj9FJ2MVNogWEy8Hfs6AKewI9S3ra@ItMGPnA7DprRKM8BWOQVzCcAT8xyCEF1JJnp1GUYrjZz2LqGceR0s0mczX6TrGkwlRThSnyAvDiOknsfjS0ksvGXh6uyJ4@fqXFQHzgg46u13hb17cQV9DWLGsycQLAsA5Rt/ts0zFH5mG7R@W9QcO5vCSb2vZ5NnuoGm0Dmfj8g7Hsk5/@/L@bPL7p89DNA8iL4Xdr3D3ePAye/P@z@KN23vz7s3rd8fu8cu3rwfH7qs3@Plx/@0DWJZotHXlBWs8ZMx@V6l1GJofwI6XAFQm5Xe2DOg/RyF2UPcEqVuZJcA8oELkJ@B7qRdeYEavg1oGUmDRMHUctpv8xZ4PhiTa@TWOo7g1ty@idTBjaEMw4SrGKTUpxYw84uMx9gLEKS0A8I7@PorvQX0EKQ6I34BIwBnFRMQAc89UbgkMMLsra5SUwhmKYkqWc0hAFAYZGAROX6X5jbzJiM6iJYQ2wuSxQlyNDQxiYYiCkDqHaiS202HuIOCm6uOqpLIejRn3vQl1HB1uhgq9oCHVIysKUo7gEvuLyxSdoIGIJlkHxLv1DDL@xgIHjrI1R9vN0ozAHQPhjIjcC05DJC5ekD/6RhJbxVtiNpecGkJWrk4Gy7qAlJsYYo2pmoURW2AySkuJvwiHxOIWe54kQZQmND3d5fzaFJUty2efZY5MagX8zutFz@4IWxlR3Wau8urthEHdZrJu3HrPpCE5bTLxQz@dTFoJ5NEhItm0gxomuXaW5/Lk2ae5TTb27jnt0fJaHjubpLHm3OjSmDZ9yTkWMpirIydlsTxNLtcJUMJoATTSrGS7RjLEzCw@wF5S1Glznmoih2Z9IcrQmKGRGWZUqA/mIU6eNEDcy8dy/pLV0oCvLejfGBNike6INeW1LNPIaZL8QY@HoBeChOiFC9wq71SYzHgQtdluo5sqJd3oFcR8fiyVPs3ufq9vVlNfQKnaMydxolIooXGl12VUpQ1dt/Sei4O69EelRNLL60s/wDmnrokw3/1cZVYkndcaoUI6VhUuxquQWL1pIuVVmhvJDyE3crcGgtAfYwrs0H@5lxXh6kiByvdlSiRaVCymQJTLdgYhsTybKaWAngPqSkFFR6uvABTrphWAsf05Sj9lZzE8yyHYeUUT0JxUlTZFdyyFkKkZqcNL45IC1aEmu@VtkmtBORiQ4x3HxZuURjyyPok6FRwA2RNF49QxDr7L943ob7ZLpnoRYXISK4hAc8rgyGlTzR8MeqyLSs4@3dsge3BwirCt7Crv4Fy6sgKAVSre5lxK1mrKJN0kxFlsDDTKY308aWKpNnKaujBoSnFJVUB9KAry4b8fJ43smEK2ThKK/YuIFgOcdEZyeVKCdheNUqHK5YQuDzdNZmIfkJdSkXVLLYdFkCu9kbjkFArT9EIypMxXRkboTqETkqs/552BtgU5RTUt8P/P8WSjnog@Z8w7Z7HSNwl1haIZNUJz6gVJNR5tQyiFSjaQMAWDDmvZc6tlq8jAai3dW0Qu0idXO1BX25en6Xhq7Gr78zSwcjnzw@Kw3NKnYs/niEiCp8zY0M9G@3H7xu46OoTMeLLHzBg8ZcZDdbVDyIwn@/O05Tp4mleQm7FGg4YSrX7dGOAxBhHt5oOIsj/weyz5nNAic7p8YtFB8lk2e5nRE95Whbh8uDN6tnD51SgSunyDOAwwevEhDAPaOw8DQvwzDAOO5GEAxKQUPEd7rK8hXpT7QbOqzLe/NYPm7O6XCtSWJvWy9wu8raJkM96KoZqE5Xobn@mgZTRbB9GQ3bDXfm6xS7InFmbUxI8iNikB6tUWp0uwl25fmLOOdBU58@NueX4q3LO7fOLZIFPxHSVosx@5NdHC7mUYo9peJZfwFygx@vGrwEFbubmUGDe95GPfF1DErPo8vs/yXFVJTNnYbVaZH6fe89a0X3MJbV944bMU4ZsVOH6Y@l6K0bWfXiLIT0D2Cid2VTtBzLx96@Ju1roAKTKeFWmNDKRaWag4pLfoqvcLGjEGJdxlF96p2kiVo3xvqb0/ac5p6epwXtx@5t/OyV0Vb@HNJ5ZNPK@2Z9LWraL92@ReSzmIuENzVZe6S1Yp5b6IUZTxmxXHB9/ZEaxhwPb6GzbIDfrvWo2JvamxEvNauFXBrWlYqZMWtbVcV/NyMZaOAsUFTNWpeMtmyPBBnPYjgi3PBs178t2b8hiv4nKjlqTxxpdJc/uu@HahB92pt4SG/z4P@buC83vHrjlfbkThTnDr@8bUKpP/3O627vKj5FEs4zBoGfgTqBLr2JAeSnde5AbaJEndzZpBPMGgYLr92NPub2UkICXPnrdSvajH83Ok6sXdxh5aPLLu1tODPKIK9Qicp9UtVZzNw94o6iPOGliuJgLI31xswX8ar/HMv/oJh341bTJtzv/CcfTRvwIZorDo0YlYoDN/hsn/S/kHYOwtDhO1BWfj0Vz3PzCaq/S3QxjPvdiqE3jQfvvqDl471iomxecGusAbcpYesE9St1l9@Bc) of this notation is provided in Python that let's you test reasonably sized values.
  
[Answer]
## Windows 2000 - Windows 8 (3907172 / 23³ = 321)
**NOTE: *DON'T F'ING RUN THIS!***
Save the following to a batch file and run it as Administrator.
```
CD|Format D:/FS:FAT/V/Q
```
Output when run on a 4TB drive with the first printed number in bold.
> 
> Insert new disk for drive D:  
> 
>  and press ENTER when ready... The type of the file system is NTFS.  
> 
>  The new file system is FAT.  
> 
>  QuickFormatting **3907172M**  
> 
>  The volume is too big for FAT16/12. 
> 
> 
> 
[Answer]
## GolfScript, score: *way* too much
OK, how big a number can we print in a few chars of GolfScript?
Let's start with the following code ([thanks, Ben!](https://codegolf.stackexchange.com/a/18050)), which prints `126`:
```
'~'(
```
Next, let's repeat it 126 times, giving us a number equal to about 1.26126 × 10377:
```
'~'(.`*
```
(That's string repetition, not multiplication, so it should be OK under the rules.)
Now, let's repeat *that* 378-digit number a little over 10377 times:
```
'~'(.`*.~*
```
You'll never actually see this program finish, since it tries to compute a number with about 10380 ≈ 21140 digits. No computer ever built could store a number that big, nor could such a computer ever be built using known physics; the [number of atoms in the observable universe](//en.wikipedia.org/wiki/Observable_universe#Matter_content_.E2.80.94_number_of_atoms) is estimated to be about 1080, so even if we could somehow use *all the matter in the universe* to store this huge number, we'd still somehow have to cram about 10380 / 1080 = 10300 digits into *each atom!*
But let's assume that we have God's own GolfScript interpreter, capable of running such a calculation, and that we're still not satisfied. OK, *let's do that again!*
```
'~'(.`*.~*.~*
```
The output of this program, if it could complete, would have about 1010383 digits, and so would equal approximately 101010383.
But wait! That program is getting kind of repetitive... why don't we turn it into a loop?
```
'~'(.`*.{.~*}*
```
Here, the loop body gets run about 10377 times, giving us a theoretical output consisting of about 1010⋰10377 digits or so, where the tower of [iterated powers](//en.wikipedia.org/wiki/Tetration) of 10 is about 10377 steps long. (Actually, that's a gross underestimate, since I'm neglecting the fact that the number being repeated also gets longer every time, but relatively speaking that's a minor issue.)
But we're not done yet. Let's add another loop!
```
'~'(.`*.{.{.~*}*}*
```
To even properly write down an *approximation* of such numbers requires esoteric mathematical notation. For example, in [Knuth up-arrow notation](//en.wikipedia.org/wiki/Knuth%27s_up-arrow_notation), the number (theoretically) output by the program above should be about 10 ↑3 10377, give or take a few (or 10377) powers of ten, assuming I did the math right.
Numbers like this get way beyond just "incredibly huge", and into the realm of "inconceivable". As in, not only is it impossible to count up to or to write down such numbers (we crossed beyond that point already at the third example above), but they literally have no conceivable use or existence outside abstract mathematics. We can prove, from the [axioms of mathematics](//en.wikipedia.org/wiki/Foundations_of_mathematics), that such numbers exist, just like we can prove from the GolfScript specification that program above *would* compute them, if the limits of reality and available storage space did not intervene), but there's literally *nothing* in the physical universe that we could use them to count or measure in any sense.
Still, mathematicians do sometimes make use of [even larger numbers](//en.wikipedia.org/wiki/Graham%27s_number). (Theoretically) computing numbers *that* large takes a little bit more work — instead of just nesting more loops one by one, we need to use recursion to telescope the *depth* of the nested loops. Still, in principle, it should be possible to write a short GolfScript program (well under 100 bytes, I would expect) to (theoretically) compute any number expressible in, say, [Conway chained arrow notation](//en.wikipedia.org/wiki/Conway_chained_arrow_notation); the details are left as an exercise. ;-)
[Answer]
# JavaScript 44 chars
This may seem a little cheaty:
```
alert((Math.PI+''+Math.E).replace(/\./g,""))
```
**Score = 31415926535897932718281828459045 / 44^3 ≈ 3.688007904758867e+26 ≈ 10↑↑2.1536134004**
[Answer]
# C, score = 101097.61735/983 ≈ 10↑↑2.29874984
```
unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}
```
I appreciate the help in scoring. Any insights or corrections are appreciated. Here is my method:
**n** = the concatenation of **every number from 1 to 264-1, repeated (264-1)4 times**. First, here's how I'm estimating (low) the cumulative number of digits from 1 to 264-1 (the "subsequence"): The final number in the subsequence sequence is 264-1 = `18446744073709551615` with 20 digits. Thus, more than 90% of the numbers in the subsequence (those starting with `1`..`9`) have 19 digits. Let's assume the remaining 10% average 10 digits. It will be much more than that, but this is a low estimate for easy math and no cheating. That subsequence gets repeated (264-1)4 times, so the *length* of **n** will be *at least* (0.9×(264-1)×19 + 0.1×(264-1)×10) × (264-1)4 = 3.86613 × 1097 digits. In the comments below, @primo confirms the length of **n** to be 4.1433x1097. So **n** itself will be 10 to that power, or 101097.61735.
**l** = 98 chars of code
**score** = **n/l3** = **101097.61735/983**
Requirement: Must run on a 64-bit computer where `sizeof(long) == 8`. Mac and Linux will do it.
[Answer]
## GolfScript; score at least fε\_0+ω+1(17) / 1000
Following [r.e.s.](https://codegolf.stackexchange.com/users/3440/r-e-s)'s suggestion to use the [Lifetime of a worm](https://codegolf.stackexchange.com/q/18912/194) answer for this question, I present two programs which vastly improve on his derivation of Howard's solution.
They share a common prefix, modulo the function name:
```
,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g
```
computes `g(g(1)) = g(5)` where `g(x) = worm_lifetime(x, [x])` grows roughly as fε0 (which r.e.s. notes is "the function in the [fast-growing hierarchy](https://en.wikipedia.org/wiki/Fast-growing_hierarchy#Functions_in_fast-growing_hierarchies) that grows at roughly the same rate as the Goodstein function").
The slightly easier (!) to analyse is
```
,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*
```
`.{foo}*` maps `x` to `foo^x x`.
```
,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*
```
thus gives `g^(g(5)) ( g(5) )`; the further 8 levels of iteration are similar to arrow chaining. To express in simple terms: if `h_0 = g` and `h_{i+1} (x) = h_i^x (x)` then we calculate `h_10 (g(5))`.
I think this second program almost certainly scores far better. This time the label assigned to function `g` is a newline (sic).
```
,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^
```
This time I make better use of `^` as a different function.
```
.['.{
}*'n/]*zip n*~
```
takes `x` on the stack, and leaves `x` followed by a string containing `x` copies of `.{` followed by `g` followed by `x` copies of `}*`; it then evaluates the string. Since I had a better place to burn spare characters, we start with `j_0 = g`; if `j_{i+1} (x) = j_i^x (x)` then the first evaluation of `^` computes `j_{g(5)} (g(5))` (which I'm pretty sure already beats the previous program). I then execute `^` 16 more times; so if `k_0 = g(5)` and `k_{i+1} = j_{k_i} (k_i)` then it calculates `k_17`. I'm grateful (again) to r.e.s. for estimating that `k_i` >> fε\_0+ω+1(i).
[Answer]
# Python 3 - 99 chars - (most likely) significantly larger than Graham's number
I've come up with a more quickly increasing function based on an extension of the Ackermann function.
```
A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))
```
<http://fora.xkcd.com/viewtopic.php?f=17&t=31598> inspired me, but you don't need to look there to understand my number.
Here is the modified version of the ackermann function that I'll be using in my analysis:
```
A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)
```
My function `A` in the code above is technically not the same, but it is actually stronger, with the following statement to replace the third line of the above definition:
```
A(a,0,...)=A(a-1,a,...)
```
(a has to be at least 1, so it has to be stronger)
But for my purposes I will assume that it is the same as the simpler one, because the analysis is already partially done for Ackermann's function, and therefore for this function when it has two arguments.
My function is guaranteed to eventually stop recursing because it always either: removes an argument, decrements the first argument, or keeps the same first argument and decrements the second argument.
# Analysis of size
Graham's number, AFAIK, can be represented as `G(64)` using:
```
G(n) = g^n(4)
g(n) = 3 ↑^(n) 3
```
Where a `↑^(n)` b is knuth's up-arrow notation.
As well:
```
A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.
g(g(n)) ≈ A(A(n+2,100),100)
A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)
g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)
g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)
```
The number expressed in the program above is `A(0,1,2,3,4,...,123,124,125)`.
Since `g^64(4)` is Graham's number, and assuming my math is correct then it is less than `A(1,64,100)`, my number is *significantly* larger than Graham's number.
Please point out any mistakes in my math - although if there aren't any, this should be the largest number computed so far to answer this question.
[Answer]
## Perl - score ≈ 10↑↑4.1
```
$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/
```
Once again abusing perl's regex engine to grind through an unimaginable amount of combinations, this time using a recursive descent.
In the inner most of the expression, we have a bare `.` to prevent infinite recursion, and thus limiting the levels of recursion to the length of the string.
What we'll end up with is this:
```
/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .
```
... repeated *671088640* times, for a total of *12750684161* nestings - which quite thoroughly puts my previous attempt of *23* nestings to shame. Remarkably, perl doesn't even choke on this (once again, memory usage holds steady at about 1.3GB), although it will take quite a while before the first print statement is even issued.
From my previous analysis below, it can be concluded that the number of digits output will be on the order of *(!12750684161)671088640*, where *!k* is the [Left Factorial](http://mathworld.wolfram.com/LeftFactorial.html) of *k* (see [A003422](http://oeis.org/A003422)). We can approximate this as *(k-1)!*, which is strictly smaller, but on the same order of magnitude.
And if we [ask wolframalpha](http://www.wolframalpha.com/input/?i=10%5E12750684160%21%5E671088640):
![](https://i.stack.imgur.com/zvT9z.png)
...which barely changes my score at all. I thought for sure that'd be at least **10↑↑5**. I guess the difference between **10↑↑4** and **10↑↑4.1** is a lot bigger than you'd think.
---
## Perl - score ≈ 10↑↑4
```
$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/
```
Abusing the perl regex engine to do some combinatorics for us. The embedded codeblock  
`(??{print})` will insert its result directly into the regex. Since `$_` is composed entirely of `2`s (and the result of `print` is always `1`), this can never match, and sends perl spinning through all possible combinations, of which there's quite a few.
**Constants used**
* `$^F` - the maximum system file handle, typically `2`.
* `$]` - the perl version number, similar to `5.016002`.
`$_` is then a string containing the digit `2` repeated *671088640* times. Memory usage is constant at about 1.3GB, output begins immediately.
**Analysis**
Let's define *Pk(n)* to be the number of times the print statement is executed, where *k* is the number of nestings, and *n* is the length of the string plus one (just because I don't feel like writing *n+1* everywhere).
`(.*.*)*`  
*P2(n)* = [*2, 8, 28, 96, 328, 1120, 3824, 13056, ...*]
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=P_2%28n%29%3D%5Cfrac%7B1%7D%7B1%5Csqrt%7B2%7D%7D%28%282%2B%5Csqrt%7B2%7D%29%5En-%282-%5Csqrt%7B2%7D%29%5En%29%2B%5Cfrac%7B0%7D%7B1%7Dn)
`((.*.*)*)*`  
*P3(n)* = [*3, 18, 123, 900, 6693, 49926, 372615, 2781192, ...*]
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=P_3%28n%29%3D%5Cfrac%7B2%7D%7B2%5Csqrt%7B12%7D%7D%28%284%2B%5Csqrt%7B12%7D%29%5En-%284-%5Csqrt%7B12%7D%29%5En%29%2B%5Cfrac%7B2%7D%7B2%7Dn)
`(((.*.*)*)*)*`  
*P4(n)* = [*4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ...*]
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=P_4%28n%29%3D%5Cfrac%7B4%7D%7B3%5Csqrt%7B12%7D%7D%28%2810%2B%5Csqrt%7B90%7D%29%5En-%2810-%5Csqrt%7B90%7D%29%5En%29%2B%5Cfrac%7B4%7D%7B3%7Dn)
`((((.*.*)*)*)*)*`  
*P5(n)* = [*5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ...*]
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=P_5%28n%29%3D%5Cfrac%7B40%7D%7B22%5Csqrt%7B1122%7D%7D%28%2834%2B%5Csqrt%7B1122%7D%29%5En-%2834-%5Csqrt%7B1122%7D%29%5En%29%2B%5Cfrac%7B30%7D%7B22%7Dn)
`(((((.*.*)*)*)*)*)*`  
*P6(n)* = [*6, 1452, 445698, 137050584, 42142941390, 12958920156996, ...*]
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=P_6%28n%29%3D%5Cfrac%7B240%7D%7B102%5Csqrt%7B23562%7D%7D%28%28154%2B%5Csqrt%7B23562%7D%29%5En-%28154-%5Csqrt%7B23562%7D%29%5En%29%2B%5Cfrac%7B132%7D%7B102%7Dn)
`((((((.*.*)*)*)*)*)*)*`  
*P7(n)* = [*7, 10094, 17634981, 30817120348, 53852913389555, ...*]
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=P_7%28n%29%3D%5Cfrac%7B1120%7D%7B388%5Csqrt%7B763002%7D%7D%28%28874%2B%5Csqrt%7B763002%7D%29%5En-%28874-%5Csqrt%7B763002%7D%29%5En%29%2B%5Cfrac%7B476%7D%7B388%7Dn)
etc. In general, the formula can be generalized as the following:
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=P_k%28n%29%3D%5Cfrac%7BC_k%7D%7BE_k%5Csqrt%7BB_k%7D%7D%28%28A_k%2B%5Csqrt%7BB_k%7D%29%5En-%28A_k-%5Csqrt%7BB_k%7D%29%5En%29%2B%5Cfrac%7BD_k%7D%7BE_k%7Dn)
where
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=A_k%3D%21k%3D%5Csum%5Climits_%7Bn%3D0%7D%5E%7Bk-1%7D%7Bn%21%7D)
That is, the [Left Factorial](http://mathworld.wolfram.com/LeftFactorial.html) of *k*, i.e. the sum of all factorials less than *k* (see [A003422](http://oeis.org/A003422)).
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=B_k%3DA_k%28A_k-1%29)  
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=C_k%3D2%5E%7Bk-2%7D%7Bk%5Cchoose+4%7D)
I've been unable to determine closed forms for *Dk* and *Ek*, but this doesn't matter too much, if we observe that
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=%5Clim_%7Bk%5Cto%5Cinfty%7D%5Cfrac%7BC_k%7D%7BE_k%7D%3D%5Cfrac%7Bk-1%7D%7B2%7D) and ![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=%5Clim_%7Bk%5Cto%5Cinfty%7D%5Cfrac%7BD_k%7D%7BE_k%7D%3D1)
With *23* nestings, this gives us an approximate score of:
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=%5Cfrac%7B2%7D%7B9%7D10%5E%7B671088640%5Ccdot%2822%5Ccdot%281177652997443428940314%2B%5Csqrt%7B1386866582387492850230084014226553545478282%7D%29%5E%7B671088640%7D%2B671088641%29-6%7D)
This should be nearly exact, actually.
But to put this into a notation that's a bit easier to visualize, we can approximate the base of the inner exponent:
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=1177652997443428940314%2B%5Csqrt%7B1386866582387492850230084014226553545478282%7D%5Capprox+10%5E%7B21.372%7D)
and then the exponent itself:
![](https://chart.googleapis.com/chart?cht=tx&chf=bg,s,FFFFFF00&chl=%2810%5E%7B21.372%7D%29%5E%7B671088640%7D%5Capprox+10%5E%7B14342506414%7D)
and then [ask wolframalpha](http://www.wolframalpha.com/input/?i=2%2F9*10%5E%28671088640*%2822*%2810%5E14342538182%29%2B671088641%29-6%29):
![](https://i.stack.imgur.com/R3q2F.png)
which you may as well just call **10↑↑4** and be done with it.
[Answer]
# Javascript, 10↑↑↑↑210
100 chars:
```
z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)
```
Based on the observation that maximally iterating `f` is the optimal way to go, I replaced the 13 calls to `f` with 3 levels of nested loops calling `f`, `z` times each (while `f` keeps increasing `z`).
I estimated the score analytically on a piece of paper—I'll type it up if anyone is interested in seeing it.
---
# Improved Score: 10↑↑13
Javascript, in exactly 100 characters, again:
```
z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)
```
This improves my original answer in three ways—
1. Defining `z` on the global scope saves us from having to type `o.z` each time.
2. It's possible to define a getter on the global scope (window) and type `f` instead of `o.f`.
3. Having more iterations of `f` is worth more than starting with a larger number, so instead of `(Math.E+'').replace('.','')` (=2718281828459045, 27 chars), it's better to use `~~Math.E+''` (=2, 11 chars), and use the salvaged characters to call `f` many more times.
Since, as analyzed further below, each iteration produces, from a number in the order of magnitude *M*, a larger number in the order of magnitude 10M, this code produces after each iteration
1. 210 ∼ O(102)
2. O(10102) ∼ O(10↑↑2)
3. O(1010↑↑2) = O(10↑↑3)
4. O(1010↑↑3) = O(10↑↑4)
5. O(1010↑↑4) = O(10↑↑5)
6. O(1010↑↑5) = O(10↑↑6)
7. O(1010↑↑6) = O(10↑↑7)
8. O(1010↑↑7) = O(10↑↑8)
9. O(1010↑↑8) = O(10↑↑9)
10. O(1010↑↑9) = O(10↑↑10)
11. O(1010↑↑10) = O(10↑↑11)
12. O(1010↑↑11) = O(10↑↑12)
13. O(1010↑↑12) = O(10↑↑13)
---
# Score: ∼101010101016 ≈ 10↑↑6.080669764
Javascript, in exactly 100 characters:
```
o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)
```
Each `o.f` invokes the while loop, for a total of 5 loops. After only the first iteration, the score is already over 1042381398144233621. By the second iteration, Mathematica was unable to compute even the *number of digits* in the result.
Here's a walkthrough of the code:
## Init
Start with 2718281828459045 by removing the decimal point from `Math.E`.
## Iteration 1
Concatenate the decreasing sequence of numbers,
* 2718281828459045
* 2718281828459044
* 2718281828459043
* ...
* 3
* 2
* 1
* 0
to form a new (gigantic) number,
* 271828182845904527182818284590442718281828459043...9876543210.
How many digits are in this number? Well, it's the concatenation of
* 1718281828459046 16-digit numbers
* 900000000000000 15-digit numbers
* 90000000000000 14-digit numbers,
* 9000000000000 13-digit numbers
* ...
* 900 3-digit numbers
* 90 2-digit numbers
* 10 1-digit numbers
In Mathematica,
```
In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626
```
In other words, it's 2.72⋅1042381398144233625.
Making my score, after only the first iteration, **2.72⋅1042381398144233619**.
## Iteration 2
But that's only the beginning. Now, repeat the steps, *starting with the gigantic number*! That is, concatenate the decreasing sequence of numbers,
* 271828182845904527182818284590442718281828459043...9876543210
* 271828182845904527182818284590442718281828459043...9876543209
* 271828182845904527182818284590442718281828459043...9876543208
* ...
* 3
* 2
* 1
* 0
So, what's my new score, Mathematica?
```
In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1
During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>
During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>
Out[2]= Overflow[]
```
## Iteration 3
Repeat.
## Iteration 4
Repeat.
## Iteration 5
Repeat.
---
## Analytical Score
In the first iteration, we calculated the number of digits in the concatenation of the decreasing sequence starting at 2718281828459045, by counting the number of digits in
* 1718281828459046 16-digit numbers
* 900000000000000 15-digit numbers
* 90000000000000 14-digit numbers,
* 9000000000000 13-digit numbers
* ...
* 900 3-digit numbers
* 90 2-digit numbers
* 10 1-digit numbers
This sum can be represented by the formula,
        ![enter image description here](https://i.stack.imgur.com/7VKrb.png)
where *Z* denotes the starting number (*e.g.* 2718281828459045) and *OZ* denotes its order of magnitude (*e.g.* 15, since *Z* ∼ 1015). Using [equivalences for finite sums](http://en.wikipedia.org/wiki/List_of_mathematical_series#Low-order_polylogarithms), the above can be expressed explicitly as
        ![enter image description here](https://i.stack.imgur.com/5TXDI.png)
which, if we take 9 ≈ 10, reduces even further to
        ![enter image description here](https://i.stack.imgur.com/SOwKs.png)
and, finally, expanding terms and ordering them by decreasing order of magnitude, we get
        ![enter image description here](https://i.stack.imgur.com/mA2rx.png)
Now, since we're only interested in the order of magnitude of the result, let's substitute *Z* with "a number in the order of magnitude of *OZ*," *i.e.* 10*OZ*—
        ![enter image description here](https://i.stack.imgur.com/JUDH8.png)
Finally, the 2nd and 3rd terms cancel out, and the last two terms can be dropped (their size is trivial), leaving us with
        ![enter image description here](https://i.stack.imgur.com/BSWus.png)
from which the first term wins out.
**Restated, `f` takes a number in the order of magnitude of *M* and produces a number approximately in the order of magnitude of *M*(10*M*).**
The first iteration can easily be checked by hand. 2718281828459045 is a number in the order of magnitude of 15—therefore `f` should produce a number in the order of magnitude of 15(1015) ∼ 1016. Indeed, the number produced is, from before, 2.72⋅1042381398144233625—that is, 1042381398144233625 ∼ 101016.
Noting that *M* is not a significant factor in *M*(10*M*), the order of magnitude of the result of each iteration, then, follows a simple pattern of tetration:
1. 1016
2. 101016
3. 10101016
4. 1010101016
5. 101010101016
---
### LaTeX sources
```
(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1
(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}
(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1
Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2
\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2
\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}
```
[Answer]
# APL, 10↑↑3.4
Here's my revised attempt:
```
{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D
```
100 char/byte\* program, running on current hardware (uses a negligible amount of memory and regular 32-bit int variables) although it will take a very long time to complete.
You can actually run it on an APL interpreter and it will start printing digits. If allowed to complete, it will have printed a number with 10 × 12345678944 digits.
Therefore the score is 1010 × 12345678944 / 1003 ≈ 1010353 ≈ 10↑↑3.406161
**Explanation**
* `⎕D` is a predefined constant string equal to `'0123456789'`
* `n←⍎⎕D` defines **n** to be the number represented by that string: 123456789 (which is < 231 and therefore can be used as a loop control variable)
* `{⍞←⎕D}` will print the 10 digits to standard output, without a newline
* `{⍞←⎕D}⍣n` will do it **n** times (`⍣` is the "power operator": it's neither \*, /, nor ^, because it's not a math operation, it's a kind of loop)
* `{⍞←n}⍣n⍣n` will repeat the previous operation **n** times, therefore printing the 10 digits **n**2 times
* `{⍞←n}⍣n⍣n⍣n` will do it **n**3 times
* I could fit 44 `⍣n` in there, so it prints **n**44 times the string `'0123456789'`.
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯  
\*: APL can be written in its own (legacy) single-byte charset that maps APL symbols to the upper 128 byte values. Therefore, for the purpose of scoring, a program of N chars *that only uses ASCII characters and APL symbols* can be considered to be N bytes long.
[Answer]
# Haskell, score: (22265536-3)/1000000 ≈ 2↑↑7 ≈ 10↑↑4.6329710779
```
o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q
```
This program is exactly 100 bytes of pure Haskell code. It will print the fourth Ackermann number, eventually consuming all available energy, matter and time of the Universe and beyond in the process (thus *slightly* exceeding the soft limit of 5 seconds).
[Answer]
# Ruby, \$f\_{\varphi(1,0,0)}(5)\$ (non-deterministic)
More precisely: \$f\_{\varphi(\varphi(\varphi(\varphi(\varphi(16381,\omega^2),\omega^2),\omega^2),\omega^2),\omega^2)}(1048577)\$.
```
*h=[[[[n=$$]]]]
f=->a{b,c,d=a;b ?a==b ?~-a:a==a-[$.]?[f[b],d,[b,f[c],d]]:d:n+=n}
h=f[h]while h!=p(n)
```
[Try it online!](https://tio.run/##DcZNCgIxDIbh/ZxihC78ST1A5XMOErJIppYIUkQQEdGr1zyLl/fxtPcYeweHjpQkTA35rB@jlSr0ZPOiQPSXtcRp5nSUhRubUCU2arzGiZRa@gH9Ozkau7z8ervMvsF923dj/AE)
\*`$. == 0` is a global variable.
\*Relies on `$$`, the [process ID](https://stackoverflow.com/a/2177022/7741591). I suppose the rules never said random behavior isn't allowed. I'm assuming the maximum PID to be 32768.
# Ruby, \$f\_{\varphi(1,0,0)}(3)\$ (deterministic)
More precisely: \$f\_{\varphi(\varphi(\varphi(\omega+\omega,\omega^2),\omega^2),\omega)}(16)\$.
```
*h=[[[n=-~$.]]]
f=->a{b,c,d=a;b ?a==b ?~-a:a==a-[$.]?[f[b],d,[b,f[c],d]]:d:n+=n}
h=f[h]while h!=p(n)
```
[Try it online!](https://tio.run/##DcpBCsIwEEbhfU9RoYuqEw8Q@e1BhlnMNIYplCCCFCn26jGbx7d47499a704mLkgHMNNRLqM8NDdaKYEvVs/KdB6BI1NGrhtE2c2oURslHluEokplivKr3Nkdtl8WZ@9n/Aay7nWPw)
\*Previously removed the prints, not sure why but they're back since removing them doesn't really let us improve much. Probably just +1 (or +2 at best) inside the \$f\_{\varphi(1,0,0)}(n+\dots)\$.
### Ungolfed:
\*See math explanation below.
```
n = 32768         # n = "count"
h = [[[[[n]]]]]   # h0 = 32768
                  # h1 = "count op(h0) count"
                  # ...
                  # h = h5 = "count op(h4) count"
f = -> a {        # f[a] = reduce(a)
  b, c, d = a                     # truncate to first 3 elements
  if a == [] || a.nil?            # if a == "count"
    n += n                          # increment counter
    return n                        # and replace with counter
  elsif a.is_a? Integer           # if a == int
    return a - 1                    # decrement int
  elsif a != a-[0]                # if a == "++d"
    return d                        # return just d
  else                            # if a == "d op c" where b = op  (*note out of order)
    return [f[b], d, [b, f[c], d]]  # (d op reduce(c)) reduce(op) d
  end
}
while h != n  # reduce until h == n
  h = f[h]
  p(n)
end
```
\*We write `"x op(y) z" = [y, z, x]` so that reducing it reduces `y` before `z` and so that `[t] = "count op(t) count"`.
### Math explanation:
The code may be approximately understood as a combination of symbolic manipulation and recursive reduction of algebraic expressions.
Let `++a` denote `a+1`, the successor of `a`.
We then define `reduce("x")` as `x-1`, meaning:
* `reduce("++a") = a`.
We then try to work out `reduce("x")` for algebraic expressions:
* `reduce("a+b") = a + reduce("b") = reduce("++(a + reduce("b"))")`
* `reduce("a*b") = reduce("a*reduce("b") + a")`
* `reduce("a^b") = reduce("a^reduce("b") * a")`
Generalizing this, we get:
* `reduce("a op b") = reduce("(a op reduce(b)) reduce("op") a")`
where:
* `reduce("*") = "+"`
* `reduce("^") = "*"`
and more generally:
* `reduce("op(n)") = op(reduce("n"))`
* `x op(0) y = ++x`
* `x op(1) y = x+y`
* `x op(2) y = x*y`
* `x op(3) y = x^y`
for simplicity we also define:
* `x op 0 = ++x`
We then introduce **symbols**. The only symbol is `"count"`, where `reduce("count")` is the amount of times `reduce` has been called.
We then apply `x = reduce(x)` until `x = 0` and print the `count`.
### Example:
```
"count^3"
1:  reduce("count^3")
2:  reduce("count^reduce(3) reduce("^") count")
      Note: we evaluate right-to-left
3:  reduce("count^reduce(3) * count")
4:  reduce("count^2 * count")
5:  reduce("count^2 * reduce("count") reduce("*") count^2")
6:  reduce("count^2 * reduce("count") + count^2")
7:  reduce("count^2 * 6 + count^2")
8:  reduce("count^2 * 6 + reduce("count^2") reduce("+") ...")
9:  reduce("++(count^2 * 6 + reduce("count^2"))")
10: reduce("++(count^2 * 6 + count^reduce(2) reduce("^") count)")
11: reduce("++(count^2 * 6 + count^reduce(2) * count)")
12: reduce("++(count^2 * 5 + count^1 * count)")
"count^2 * 6 + count^1 * count"
(continue applying reduce(...) until you get 0)
```
Note that the growth relies on the 'lazy' evaluation of `"count"`. Despite how simple it is to normally cube an integer, fully reducing `"count^3"` actually results in `count > 10^10^10^10^10^10^5`.
**Let `g(x, n)` be** the final `count` after fully reducing `x` with an initial `count = n`.
So from the previous example, `g("count^3", 0) > 10^10^10^10^10^10^5`.
**For some intuition on the very fast growth**, notice that `g("a+b", n) > g(a, g(b, n))`. This is because we have to reduce `b` before `a`. This means **addition allows recursion**, and we also know that **multiplication expands into lots of addition**.
Then note that
* `g("count", n) ~ 2 * n`
* `g("count + count", n) ~ 2 * 2 * n = 4 * n`
* `g("count + count + ...", n) ~ 2 * 2 * ... * n = 2^k * n`
* `g("count * k", n) ~ 2^k * n`
* `g("count * count", n) ~ 2^n`
* `g("count ^ 2", n) ~ 2^n`
* `g("count ^ 2 + count ^ 2", n) ~ 2^2^n`
* `g("count ^ 2 * k", n) ~ 2^2^...^n`
* `g("count ^ 2 * count", n) ~ n↑↑n`
* `g("count ^ 3", n) ~ n↑↑n`
* `g("count ^ 4", n) ~ n↑↑↑n`
### Some other values of interest:
For the last 3, we define:
* `h(0, y) = y`
* `reduce(h(x, y)) = "count op(h(reduce(x), y)) count"`
```
g("count^k", n) ~ n↑↑...k arrows...↑↑n
g("count^count", n) ~ n↑↑...n arrows...↑↑n ~ Ack(n,n)
g("count^(++count)", 20) ~ Toeofdoom's a_20(1)
g("count^(++count)", 64) ~ Graham's number
g("count^(count+1)", 15) ~ eaglgenes101's number  (note count+1 turns into ++(++count))
g("count op(4) 2", 127) ~ col6y's number
g("(count op(4) 3) * count", 3) ~ my older/other number
g("count op(6) 1", 9) ~ r.e.s.'s number
g("(count op(6) 1) * (++count op(4) 1)", 17) ~ Peter Taylor's number
g(h(3, "count + count"), 126) ~ this deterministic number
g(h(5, 16381), 1048577) ~ this non-deterministic number
g("h("count", "count") * count^7", 256^26) ~ Steve H.'s number
```
[Answer]
## Python, 2↑↑11 / 830584 ≈ 10↑↑8.632971 (Knuth up arrow notation)
```
print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))
```
Probably no computer has enough memory to successfully run this, but that's not really the program's fault. With the minimum system requirements satisfied, it does work.
Yes, this is doing bit shifting on boolean values. `True` gets coerced to `1` in this context. Python has arbitrary length integers.
[Answer]
## GolfScript,   ≈ fε0(fε0(fε0(fε0(fε0(fε0(fε0(fε0(fε0(126)))))))))
This is shamelessly adapted from [another answer](https://codegolf.stackexchange.com/a/18914/3440) by @Howard, and incorporates suggestions by @Peter Taylor. 
```
[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f
```
My understanding of GolfScript is limited, but I believe the `*` and `^` operators above are *not* the arithmetic operators forbidden by the OP.
(I will happily delete this if @Howard wants to submit his own version, which would doubtless be superior to this one anyway.) 
This program computes a number that's approximately fε0(fε0(fε0(fε0(fε0(fε0(fε0(fε0(fε0(126))))))))) -- a nine-fold iteration of fε0 -- where fε0 is the function in the [fast-growing hierarchy](https://en.wikipedia.org/wiki/Fast-growing_hierarchy#Functions_in_fast-growing_hierarchies) that grows at roughly the same rate as the Goodstein function. (fε0 grows so fast that the growth rates of Friedman's n(k) function and of k-fold Conway chained arrows are virtually insignificant even in comparison to just a single non-iterated fε0.) 
[Answer]
## dc, 100 characters
```
[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp
```
Given enough time and memory, this will calculate a number around 15 ↑¹⁶⁶⁶⁶⁶⁵ 15. I had originally implemented the [hyperoperation](http://en.wikipedia.org/wiki/Hyperoperation#Definition) function, but it required too many characters for this challenge, so I removed the `n = 2, b = 0` and `n >= 3, b = 0` conditions, turning the `n = 1, b = 0` condition into `n >= 1, b = 0`.
The only arithmetic operators used here are addition and subtraction.
EDIT: as promised in comments, here is a breakdown of what this code does:
```
[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h
[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i
[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j
Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b
```
As noted, this deviates from the hyperoperation function in that the base cases for multiplication and higher are replaced with the base case for addition. This code behaves as though `a*0 = a^0 = a↑0 = a↑↑0 ... = a`, instead of the mathematically correct `a*0 = 0` and `a^0 = a↑0 = a↑↑0 ... = 1`. As a result, it computes values that are a bit higher than they should be, but that's not a big deal since we are aiming for bigger numbers. :)
EDIT: I just noticed that a digit slipped into the code by accident, in the macro that performs increments for `n=0`. I've removed it by replacing it with 'F' (15), which has the side effect of scaling each increment operation by 15. I'm not sure how much this affects the final result, but it's probably a lot bigger now.
[Answer]
## GolfScript \$ \approx 3.673 \times 10^{374} = 10 \uparrow\uparrow 2.70760 \$
```
'~'(.`*
```
I think the `*` is allowed since it indicates string repetition, not multiplication.
Explanation: `'~'(` will leave 126 (the ASCII value of "~") on the stack. Then copy the number, convert it to a string, and do string repetition 126 times. This gives `126126126126...` which is approximately `1.26 e+377`. The solution is 7 characters, so divide by `7^3`, for a score of approximately `3.673e+374`
[Answer]
## Ruby, probabilistically infinite, 54 characters
```
x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x
```
x is initialized to 97. We then iterate the following procedure: Generate x random numbers between 0 and 1. If they are all the same, then terminate and print x. Otherwise, double x and repeat. Since Ruby's random numbers have 17 digits of precision, the odds of terminating at any step are 1 in (10e17)^x. The probability of terminating within n steps is therefore the sum for x=1 to n of (1/10e17)^(2^n), which converges to 1/10e34. This means that for any number, no matter how large, it is overwhelmingly unlikely that this program outputs a lesser number.
Now, of course, the philosophical question is whether a program that has less than a 1 in 10^34 chance of terminating by step n for any n can be said to ever terminate. If we assume not only infinite time and power, but that the program is given the ability to run at increasing speed at a rate that exceeds the rate at which the probability of terminating decreases, we can, I believe, in fact make the probability of terminating by *time t* arbitrarily close to 1. 
[Answer]
No more limit on runtime? OK then.
Does the program need to be runnable on modern computers?
Both solutions using a 64-bit compile, so that `long` is a 64-bit integer.
# C: greater than 10(264-1)264, which is itself greater than 1010355393490465494856447 ≈ 10↑↑4.11820744
```
long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}
```
88 characters.
To make these formulas easier, I'll use `t = 2^64-1 = 18446744073709551615`.
`main` will call `f` with a parameter of `t`, which will loop `t` times, each time printing the value `t`, and calling `f` with a parameter of `t-1`.
Total digits printed: `20 * t`. 
Each of those calls to `f` with a parameter of `t-1` will iterate `t` times, printing the value `t`, and calling f with a parameter of `t-2`. 
Total digits printed: `20 * (t + t*t)`
I tried this program using the equivalent of 3-bit integers (I set `i = 8` and had main call `f(7)`). It hit the print statement 6725600 times. That works out to `7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7` Therefore, I believe that this is the final count for the full program:
Total digits printed: `20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))`
I'm not sure how to calculate (264-1)264. That summation is smaller than (264)264, and I need a power of two to do this calculation. Therefore, I'll calculate (264)264-1. It's smaller than the real result, but since it's a power of two, I can convert it to a power of 10 for comparison with other results.
Does anyone know how to perform that summation, or how to convert (264-1)264 to 10n?
```
20 * 2^64^(2^64-1)
20 * 2^64^18446744073709551615
20 * 2^(64*18446744073709551615)
20 * 2^1180591620717411303360
10 * 2^1180591620717411303361
divide that exponent by log base 2 of 10 to switch the base of the exponent to powers of 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447
```
But remember, that's the number of digits printed. The value of the integer is 10 raised to that power, so 10 ^ 10 ^ 355393490465494856447
This program will have a stack depth of 2^64. That's 2^72 bytes of memory just to store the loop counters. That's 4 Billion Terabytes of loop counters. Not to mention the other things that would go on the stack for 2^64 levels of recursion.
Edit: Corrected a pair of typos, and used a more precise value for log2(10).
Edit 2: Wait a second, I've got a loop that the printf is outside of. Let's fix that. Added initializing `i`.
Edit 3: Dang it, I screwed up the math on the previous edit. Fixed.
---
This one will run on modern computers, though it won't finish any time soon.
# C: 10^10^136 ≈ 10↑↑3.329100567
```
#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}
```
98 Characters.
This will print the bitwise-inverse of zero, 2^64-1, once for each iteration. 2^64-1 is a 20 digit number.
Number of digits = `20 * (2^64-1)^7` = 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500
Rounding the program length to 100 characters, Score = printed number / 1,000,000
Score = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494
[Answer]
# C
(With apologies to Darren Stone)
```
long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}
```
n = 2^64 digit number (9...)
l = 100 chars of code
**score ≈ 1e+2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10↑↑3.2974890744**
[ Score = n^5/l^3 = (10^(2^320)-1)/(100^3) = (10^2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1)/(10^6) ]
Note that I deserve to be flogged mercilessly for this answer, but couldn't resist. I don't recommend acting like me on stackexchange, for obvious reasons. :-P
---
EDIT: It would be even harder to resist the temptation to go with something like 
```
long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}
```
...but I suppose that an intended but unspecified rule was that the entire run of digits making up the number must be printed.
[Answer]
# Pyth, fψ(ΩΩ)+7(25626)/1000000
```
=CGL&=.<GG?+Ibt]Z?htb?eb[XbhhZyeby@bhZhb)hbXbhhZyeb@,tb&bG<bhZ=Y[tZGG)VGVGVGVGVGVGVGVG=[YYY)uyFYHpG)
```
SimplyBeautifulArt has a [fantastic explanation](https://codegolf.stackexchange.com/a/149763/55696) of a function that both of our solutions share, namely that I define a function `y[b,G]` with a global =`g[h,n]`. The major differences are as follows:
* I begin my value at the base 256 representation of the ASCII codes for the string "abcdefghijklmnopqrstuvwxyz".
* I use bit shifting `.<` to increase the value of `G` instead of addition.
* `G` gets incremented each step that `y` gets run including the recursive cases, while SBA's `n` gets incremented outside of his `g` and thus is updated less frequently.
* Instead of being satisfied with simply doing `[[],n,n]` (which my code represents as `Y=[-1,G,G]`, I nest `Y` into itself as `Y=[Y,Y,Y]` `G` times, increasing G by calling `Y=y[Y,G]` `2(x+1)` times, where `x` is as many times as it takes the new version of `Y` to reach 0 by these repeated applications. `Y`'s value doesn't actually get reset to 0, because we calculate `x` by counting upwards using the reduce-until-seen-before builtin `u`.
* I then wrap the entirety of the above into 7 `for` loops (`VG`), which will repeat the key inner loop that nests `Y` and increases `G` until `repeat(y[Y,G],Y=0` `G` times.
* Unwrapping all of these nested `Y`s results in a number that, to the best of my understanding, blows all the other solutions out of the water. I'll hold off on adding my solution to the leaderboard until someone else confirms my math.
[Answer]
# New Ruby: score ~ fωω2+1(12622126)
where fα(n) is the fast growing hierarchy.
```
n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n
```
[Try it online!](https://tio.run/##JctBCoMwEAXQq0hwoWPNAZKM2eYOkkUm7a78FqGCSHP1qLh7m7f8ZKsV7Iv@LE8beJzSLg/KnOxrTW8ljQ@zMLfaZ3OhnIKRsRPHU6v7SBhyNN8OA6O3ivC/Z5gLolWaQHAOtR4)
The `*n` are just string and array multiplication, so they should be fine.
### Ungolfed code:
```
n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}
```
where `b.-b<=>0` returns an integer that is `1` closer to `0` than `b`.
---
### Explanation:
It prints `n` at the start of every call of `H`.
`H[[]]` doubles `n` (`n` times), i.e. `n = n<<n`.
`H[[0,a,b,c,...,z]]` calls `H[[a,b,c,...,z]]` (`n` times).
`H[[k+1,a,b,c,...,z]]` calls `H[[k]*n+[a,b,c,...,z]]` (`n` times), where `[k]*n = [k,k,...,k]`.
`H[[-1,a,b,c,...,z]]` calls `H[[n]*n+[a,b,c,...,z]]` (`n` times).
`H[[-(k+1),a,b,c,...,z]]` calls `H[[-k]*n+[a,b,c,...,z]]` (`n` times).
`H[k] = H[[k]]`.
My program initializes `n = 126`, then calls `H[-n-1]` 12622126 times.
---
### Examples:
`H[[0]]` will call `H[[]]` which applies `n = n<<n` (`n` times).
`H[[0,0]]` will call `H[[0]]` (`n` times).
`H[[1]]` will call `H[[0]*n]` (`n` times).
`H[[-1]]` will call `H[[n]*n]` (`n` times).
`H[[-1,-1]]` will call `H[[n]*n+[-1]]` (`n` times).
`H[[-3]]` will call `H[[-2]*n]` (`n` times).
[Try it online!](https://tio.run/##bctBDoIwEAXQfU/xAzsQYl1b3PYOtYsWMSHBiaGwMKRnr1ATEoFZzfz/ph/tJwSCwIVJiKKCwcQwjz0hq@fcxOs9Dg4JiXQifyep0sl4ncSKyqF9Ne73tUz7hC2p7W5rEhlyAVqjpnOLgxA4/zmpar1T1Q4pW3CdUX6Aryj4TucHutkq2hp6xN0zz@aaax3CFw)
---
See [revisions](https://codegolf.stackexchange.com/posts/120228/revisions) for other cool things.
[Answer]
## Haskell - Ackermann function applied to its result 20 times - 99 characters
This is the best haskell solution I can come up with based on the ackermann function - you may notice some similarities to n.m.'s solution, the i=round$log pi was inspired from there and the rest is coincidence :D
```
i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i
```
It runs the ackermann function on itself 20 times, starting at one, the sequence being
* 1,
* 3,
* 61,
* a(61,61),
* a(a(61,61),a(61,61)) --- we will call this a2(61), or a4(1) ---
* a3(61)
* ...
* a18(61), or a20(1). I think this is approximately g18 (see below).
As for the estimation, wikipedia says:
a(m,n) = 2↑m-2(n+3) - 3
From this we can see a3(1) = a(61,61) = 2↑5964 + 3, which is clearly greater than g1 = 3↑43, unless the 3 at the start is far more important than I think. After that, each level does the following (discarding the insignificant constants in an):
* gn = 3↑gn-13
* an ~= 2↑an-1(an-1)
If these are approximately equivalent, then a20(1) ~= g18. The final term in an, (an-1) is far greater than 3, so it is potentially higher than g18. I'll see if I can figure out if that would boost it even a single iteration and report back.
[Answer]
## **x86 machine code - 100 bytes (Assembled as MSDOS .com file)**
*Note: may bend the rules a little*
This program will output 2(65536\*8+32) nines which would put the score at
**(102524320-1) / 1000000**
As a counter this program uses the entire stack (64kiB) plus two 16bit registers
Assembled code:
```
8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858
```
Assembly:
```
ORG 0x100
SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret
b_ss:       dw 'SX'
b_sp:       db 'X'
```
[Answer]
# R - 49 41 characters of code, 4.03624169270483442\*10^5928 ≈ 10↑↑2.576681348
```
set.seed(T)
cat(abs(.Random.seed),sep="")
```
will print out [reproducing here just the start]:
```
403624169270483442010614603558397222347416148937479386587122217348........
```
[Answer]
# ECMAScript 6 - 10^3↑↑↑↑3 / 884736
(3↑↑↑↑3 is G(1) where G(64) is Graham's number)
```
u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)
```
Output: 10^3↑↑↑↑3
Hints:
`G` is the function where G(64) is Graham's number. Input is an integer. Output is a unary string written with 0. Removed for brevity.
`K` is the Knuth up-arrow function a ↑n b where a is implicitly 3. Input is n, a unary string, and b, a unary string. Output is a unary string.
`u` is "1".
`v` is "0000", or G(0)
`e` is "000".
[Answer]
**C**
The file size is 45 bytes.
The program is:
```
main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}
```
And the number produced is larger than 10^(10^(10^1.305451600608433)).
The file I redirected std out to is currently over 16 Gb, and still growing.
The program would terminate in a reasonable amount of time if I had a better computer.
My score is uncomputable with double precision floating point.
[Answer]
# GNU Bash, 10^40964096² /  80^3 ≈ 10↑↑2.072820169
```
C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'
```
C = 4096 on any reasonable system. SHLVL is a small positive integer (usually either 1 or 2 depending on whether /bin/sh is bash or not).
64 bit UNIX only:
Score: ~ 10^(40964096409640964096\*40964096409640964096) / 88^3
```
C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'
```
[Answer]
# C, 10^10^2485766 ≈ 10↑↑3.805871804
```
unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}
```
We create an array of 258048 unsigned integers. It couldn't be unsigned longs because that made the program too long. They are unsigned because I don't want to use undefined behavior, this code is proper C (other than the lack of return from main()) and will compile and run on any normal machine, it will keep running for a long time though. This size is the biggest we can legally express without using non-ascii characters.
We loop through the array starting from the last element. We print the digits of `2^32-1`, increment the element and drop the loop if the element hasn't wrapped to 0. This way we'll loop `(2^32 - 1)^254048 = 2^8257536` times, printing 10 digits each time.
Here's example code that shows the principle in a more limited data range:
```
#include <stdio.h>
unsigned int a[3],l=3,i,f;
int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}
```
The result is roughly 10^10^2485766 divided by a million which is still roughly 10^10^2485766. 
[Answer]
## Powershell (2.53e107976 / 72³ = 6.78e107970 ≈ 10↑↑1.701853371)
This takes far more than 5 seconds to run.
```
-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"
```
It retrieves and concatenates the byte length of every file on your current drive. Regex strips out any non-digit characters.
[Answer]
## Python 3, score = ack(126,126)/100^3
```
g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))
```
The f function is the ackermann function, which i have just enough space to invoke.
Edit: previously "else n+1", which was in violation of challenge rules- kudos to Simply Beautiful Art.
[Answer]
## JavaScript 98 chars
```
m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)
```
generates 2.718e+239622337 ≈ 10↑↑2.9232195202
For score of just slightly more than 2.718e+239622331 ≈ 10↑↑2.9232195197
which is the largest I can make it without the browser crashing.
(console.log(a) will show you the full output)
### Don't run these:
```
m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)
```
would output 2.718+e121333054704 ≈ 10↑↑3.0189898069 (aka 2.718\*10^(1.213\*10^12) to compare to the longer answer:
more extreme version, if it didn't crash your browser: (80 char)
```
m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)
```
which would create a number around the same size as e \* 10^(10^19) ≈ 10↑↑3.106786869689
Edit: updated code
original solution only generated 2.718e+464
]