[Question]
  [
**Updates: Time limit removed. You must be able to describe output - see new rule.**
A [pangram](http://en.wikipedia.org/wiki/Pangram) is a sentence that uses every letter in the alphabet at least once, such as:
> 
> *[The quick brown fox jumps over the lazy dog.](http://en.wikipedia.org/wiki/The_quick_brown_fox_jumps_over_the_lazy_dog)*
> 
> 
> 
A *perfect* pangram uses every letter exactly once.
Consider writing a program that is a perfect pangram, using the 95 [printable ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) characters (hex codes 20 to 7E) as the alphabet:
```
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
Such a program must contain exactly 95 characters, with each printable ASCII character occurring exactly once, but in any order. (Thus there are 95! = 1.03×10148 possibilities.)
Your task is to write this program such that the number of printable ASCII characters printed to stdout is as high as possible (i.e. prolific).
Your score is the number of printable ASCII characters your program outputs **(the *total* amount, not the *distinct* amount: `AABC` scores 4 whereas `ABC` scores 3)**. The highest score wins.
# Details
* The output may contain any characters (including duplicates) but only instances of the 95 printable ASCII characters count towards your score.
	+ You can use [this JSFiddle](http://jsfiddle.net/CalvinsHobbies/6x5c1b0c/#base) to count the number of printable ASCII characters in any string.
* If your language does not have stdout use the most appropriate alternative.
* Your program...
	+ must have finite runtime **(the time limit has been removed)**
	+ must have finite output
	+ may contain comments
	+ must compile and run without (uncaught) errors
	+ must not prompt for or require input
	+ must be time invariant and deterministic
	+ must not use external libraries
	+ must not require a network connection
	+ must not make use of external files
		- (you may use the program file itself as long as changing the file name does not alter the program's behavior)
* If this task is impossible is some language that's just too bad.
* You must give your exact output **or precisely describe it if it is too large to fit in a post**. You do not actually have to run your program. As long as it *would* run in a finite amount of time on a computer with an unbounded amount of memory it is valid.
# Example
This simplistic Python 2 program is a possible solution:
```
print 9876543210#!"$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghjklmoqsuvwxyz{|}~
```
It outputs `9876543210` which contains 10 printable ASCII characters, thus scoring 10.
  
[Answer]
# Perl, 70\*18446744073709551615\*10^987654320
```
say q{!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|}x(1e987654320*~$[)
```
Output:
```
!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|
```
repeated **18446744073709551615\*10^987654320** times.
`$[` is by default `0`, so `~$[` is equivalent to `18446744073709551615`.
As a side note, I ran out of memory trying to create the number `10^987654320`.
---
## Old Answer (7703703696):
```
say qw(!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10)x98765432
```
Output is:
```
!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10
```
repeated 98765432 times.
Note: Run all samples with `perl -Mbignum -E`
[Answer]
# GolfScript, over 2↑↑↑(9871↑↑2) chars
```
2 9871.?,{;0$[45)63]n+*~}/
#!"%&'(-:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmopqrstuvwxyz|
```
Prints an integer. Take advantage of unlimited [CPU register size](https://codegolf.stackexchange.com/users/26997/calvins-hobbies) (which determines the maximum string length in Ruby), memory and run time. The linefeed is solely for readability.
### The code
```
2             # Push 2.
9871.?        # Push b := 9871↑↑2 = 9871↑9871 = 9871**9871.
,{            # For each i from 0 to b - 1:
  ;0$         #   Discard i and duplicate the integer on the stack.
  [45)63]n+*  #   Replicate ".?\n" that many times.
  ~           #   Evaluate.
 }/           #
```
### The score
Define **b = 9871↑↑2** (see [Knuth's up-arrow notation](http://en.wikipedia.org/wiki/Knuth's_up-arrow_notation)).
* **.?** executes **f : x ↦ x↑x**.
* The inner block executes **g : x ↦ fx(x)**.
Since **f(x) = x↑x = x↑↑2**, **f2(x) = (x↑x)↑(x↑x) > x↑x↑x = x↑↑3**,  
**f3(x) = ((x↑x)↑(x↑x))↑((x↑x)↑(x↑x)) > (x↑x↑x)↑(x↑x↑x) > x↑x↑x↑x = x↑↑4** and so forth, we have  
**g(x) > x↑↑(x+1) > x↑↑x**.
* The outer block executes **h : x ↦ gb(x)**.
Since **g(x) = x↑↑x = x↑↑↑2**, **g2(x) = (x↑↑x)↑↑(x↑↑x) > x↑↑x↑↑x = x↑↑↑3**,  
**g3(x) = ((x↑↑x)↑↑(x↑↑x))↑↑((x↑↑x)↑↑(x↑↑x)) > (x↑↑x↑↑x)↑(x↑↑x↑↑x) > x↑↑x↑↑x↑↑x = x↑↑↑4** and so forth, we have **h(x) > x↑↑↑(b+1)**.
* We start with the integer **2** on the stack, so the code calculates **h(2) > 2↑↑↑(b+1).**
* The score is the number of decimal digits of **h(2)**, which is **log(h(2)) + 1 > log(2↑↑↑(b+1)) > 2↑↑↑b**.
Thus, the score is larger than **2↑↑↑(9871↑↑2)**.
**2↑↑↑n** grows at a ridiculous pace as **n** gets larger. **2↑↑↑4 := 2↑↑2↑↑2↑↑2 = 2↑↑2↑↑4 = 2↑↑65536**, which is a right-associative power tower of **65536** copies of **2**:
                                                                [![2↑↑↑4](https://i.stack.imgur.com/AQQdt.png)](http://en.wikipedia.org/wiki/Knuth's_up-arrow_notation#Computing_2.E2.86.91mn "Knuth's up-arrow notation # Computing 2↑ᵐn")                                                                 
Similarly, **2↑↑↑5 := 2↑↑(2↑↑↑4)**, which is a power tower of **2↑↑↑4** copies of **2**.
Now, the score isn't **2↑↑↑4** or **2↑↑↑5**, it's larger than **2↑↑↑b**, where **b > 2 × 1039 428**. That's a big number...
[Answer]
# Bash+coreutils, 151,888,888,888,888,905 (1.5\*10^17)
```
seq 9E15;#\!%*+,-./2346780:=@ABCDFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[
```
Outputs integers 1 to 9x1015, one per line. Takes a long time.
Why `9E15`? It turns out that GNU `seq` appears to use 64-bit floats (double) internally. The largest whole number we can represent with this type, before increment by one stops working due to lack of precision, is 253 or 9007199254740992. The closest we can get to this with exponential notation is 9E15 or 9000000000000000.
To calculate the score, I am using adding up all the numbers with a given number of digits and adding 9E15, because there is a newline between each number:
```
8000000000000001*16 + 900000000000000*15 + 90000000000000*14 + 9000000000000*13 + 900000000000*12 + 90000000000*11 + 9000000000*10 + 900000000*9 + 90000000*8 + 9000000*7 + 900000*6 + 90000*5 + 9000*4 + 900*3 + 90*2 + 9 + 9000000000000000
```
I could pipe this output through `od` for an extra order of magnitude or so, but that makes the score calculation much harder.
---
Pre-rule change answer:
# Bash+coreutils, 18,926,221,380
```
seq 1592346780;#\!%*+,-./:=@ABCDEFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[
```
Outputs 1 to 1592346780. On my mid 2012 macbook (which is not that far off the linked benchmark), this takes about 9m45s.
I couldn't resist optimizing it a bit more, even though its probably meaningless.
### Output:
```
$ time ./pangram.sh | wc
 1592346780 1592346780 18926221380
real    9m46.564s
user    11m7.419s
sys 0m10.974s
$ 
```
[Answer]
## GolfScript, ≈ 3\*10^(2\*10^7) i.e. ≈ 3x1020000000
```
 87 9654321?,`0${;.p}/#!"%&'()*+-9:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnoqrstuvwxyz|~
```
**How it works**
```
87 9654321?                "Pushes 87^9654321 to stack";
           ,               "Pushes an array [0, 1, 2 ... (87^9654321) - 1] to stack";
            `              "Creates a string representation of the array like "[0 1 2...]";
             0$            "Copies the string";
               {;.p}/      "Print the string wrapped in quotes X times";
                     #...  "This is all comment";
```
Here `X` is the character count (length) of the string representation of the array `[0, 1, 2..,(87^9654321) - 1]` which will be like `[0 1 2 3 4 ... (87^9654321) - 1]`
~~I am trying to calculate `X` here so as to find my score.
`(87^9654321) - 1` is roughly `10^(10^7.272415829713899)` with `18724742` decimal digits.~~
`X` is roughly `3*10^(2*10^7)` so `X*X` is also same only. Note that these values are on a very lower side as due to computation limitations of [(even) wolframa](http://www.wolframalpha.com/input/?i=sum%20%28floor%28log10%28x%29%29%20%2B%201%29%20for%20x%20%3D%201%20to%20%2887%5E9654321%20-%201%29), I was not able to compute `sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)` which is the true value of `X`
[Answer]
# MATLAB, 95
Code
```
char(37-5:126)% !"#$&'*+,./0489;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bdefgijklmnopqstuvwxyz{|}~
```
Output
```
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
Output contains all specified ASCII characters, each exactly once, and in order.
[Answer]
# Ruby, 89
```
p %q{!"#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnorstuvwxyz|~}
```
Output:
```
"!\"\#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnorstuvwxyz|~"
```
Contains all ASCII characters except, `p`, , `%`, `q`, `{`, and `}`.
[Answer]
# GolfScript, 93
```
{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}
```
Output:
```
{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}
}
```
Contains all ASCII characters except `"` and `'`.
[Answer]
# Golfscript - 27\*265439870
This my first Golfscript submission! :)
```
12,`{.+}6543 9870?*#!"$%&'()-/:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz|~
```
Explanation:
```
12,                     - Creates an array of ascending numbers from 0 to 11
   `                    - Converts the array to a string
    {.+}                - Duplicates the string on the stack and concatenates the two
        6543 9870?      - Calculates 6543^9870 and pushes it to the stack
                  *     - Repeat the block 6543^9870 times
                   #... - The rest is a comment
```
The output is a load of lists of numbers. Consider the following code:
```
12,`{.+}1*
```
With `12,` it produces the following array:
```
[0 1 2 3 4 5 6 7 8 9 10 11]
```
The backtick turns that into a string, passing it to the block `{.+}`. This duplicates the string and then concatenates the two, producing:
```
[0 1 2 3 4 5 6 7 8 9 10 11][0 1 2 3 4 5 6 7 8 9 10 11]
```
The `1*` tells the interpreter to execute the previous block one time (21 = 2).
So, based upon that:
```
 12,`{.+}n*
```
Outputs the output of `12,`` 2n times.
]