[Question]
  [
The [ASCII characters](http://www.asciitable.com/) from decimal code 33 to 126 are:
```
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
Notice that in most fonts, 25 of these characters have "holes" in them: (a [genus greater than 0](http://en.wikipedia.org/wiki/Genus_(mathematics)#Topology) you might say)
```
#$%&04689@ABDOPQRabdegopq
```
The other 68 "unholed" characters are:
```
!"'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}~
```
Your task is to write the shortest program possible using only the unholed characters that outputs each of the holed characters exactly once in any order.
Since Space, Tab and newlines (Line Feed and/or Carriage Return) are empty space they may appear in your program or its output. They still count towards the number of characters. Other ASCII characters may not be used (and certainly not non-ASCII characters).
**Notes**
* You do not have to use all of the unholed characters nor only one of each.
* The output may not contain unholed characters.
* The [Whitespace language](http://en.wikipedia.org/wiki/Whitespace_(programming_language)) may be used.
* Output should go to stdout or can go to a file. There should be no input.
**Bonus:** Just for fun, try printing all the unholed characters using the holed characters. I'm skeptical that it can be done in an existing language.
  
[Answer]
### GolfScript, 37 36 characters
```
[":=<?)-/! YX[]VIHKx{}|~vih"{25^}/]+
```
Try the code [here](http://golfscript.apphb.com/?c=WyI6PTw%2FKS0vISBZWFtdVklIS3h7fXx%2BdmloInsyNV59L10r&run=true).
The string contains the forbidden characters xor'ed with 25. Fortunately all characters are mapped to valid ones.
[Answer]
# Brainfuck 119
```
--[------->++<]>-.+.+.+.++++++++++.++++.++.++.+.+++++++.+.+.++.+++++++++++.+.+.+.[------>+<]>--.+.++.+.++.++++++++.+.+.
```
[Answer]
## Bonus - dc, 179 characters
Oh good, another restricted character set challenge where `P` is allowed.
```
6A44469PD684P44D4898PDB99P4008D0BP486B48BPA60BPD096P4A68666P460A0D4P690490AP8084088P6B6AB66P6BBB608P80D4BAAPA046PBAD4P60A6668P480DD96P4A040BBP848BP40DD8D0P46840B6P696B48BP48D64BAP
```
Since `dc` is apparently obscure enough to require explaining (strange to me considering the weird stuff around here!) here's an overview:
It's primarily an RPN calculator with arbitrary-precision arithmetic. But for this challenge, I'm making use of the `P` command, which interprets a number as a series of characters in base 256 and prints them. Examples: `65 P` prints `A` (ASCII code 65). `16706 P` prints `AB` (16706=65\*256+66).
Aside from that, the only other interesting feature is that it recognizes all of the hexadecimal digits `0-9A-F` even when they are not contained in a hexadecimal number. Decimal input is the default, so the input token `999` means `9 hundreds + 9 tens + 9` and `ABC` means `10 hundreds + 11 tens + 12` making it equivalent to `1122`.
The ability to use the digits `ABD` in decimal partially makes up for the inability to use `12357`, and the choice of ordering and grouping does the rest. (If I need some numbers `x`,`y`,`z` and they aren't representable with allowed digits, then I try representing `x*256*256+y*256+z` instead.)
The program can probably be made slightly shorter by using larger groups. I didn't go past 3 bytes per number.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 43 35 characters
```
tTFk"*+,-7;=?GHIKVWXYhiklnvwx"C-Ck7
```
Try it [here](http://ideone.com/FPEbsv).
Prints the characters in order except that 9 is at the beginning, newline separated.
String contains all characters 7 greater than the ones needed, except that 9 would become @, so it is special cased. Algorithm thanks to @Howard.
**Explanation:**
```
tT                print(10-1)                T=10, t(x)=x-1 if x is an int.
Fk"<string>"      for k in "<string>":
C-Ck7             print(chr(ord(k)-7))       Note that C is overloaded as ord and chr.
```
[Answer]
# Bash+coreutils, 56 bytes
```
tr \(-y \!-r<<<'*+,-7;=?GHIKVWXYhiklnvwx'
tr C-F 7-:<<<E
```
As luck would have it, adding 7 to the ascii value of the holed characters yields all unholed characters (with the exception of "9"). So we just do this transformation in reverse, then a similar transformation (subtract 12 from "E") to get the "9".
### Output:
```
#$%&0468@ABDOPQRabdegopq
9
```
[Answer]
## Perl - 47 Bytes (thanks @Dom Hastings for the update!) 
Perl - 49 Bytes
Edit, 47 bytes:
```
symlink".",':=<?)-/! YX[]VIHKx{}|~vih'^(F^_)x25
```
Original, 49 bytes:
```
symlink".",':=<?)-/! YX[]VIHKx{}|~vih'^chr(25)x25
```
This is pretty much a Perl version of Howard's solution. XORing the string with 25. The output is a file with the name `#$%&04689@ABDOPQRabdegopq`. I got the idea to use `symlink` and the file name as the output format because everything else is banned.
Here's another Perl solution I came up with. It can probably be improved a lot and it is pretty long, so I'm leaving in a readable format for now.
```
until(y/1/1/>32){s//1/}
until(y/1/1/>125+1){
    if(chr(y/1/1/)!~/[!"'()*+,-.\/12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\\\]^_`cfhijklmnrstuvwxyz{|}~]/) {
        symlink".",chr y/1/1/;
    }
    s/^/1/
}
```
This one outputs many files, the name of each one is one of the characters. I couldn't figure out how to append strings without using a forbidden character.
`for`, `while`, `map`, `say`, `print`, `eval`, `s///e`, and any variable name cannot be used (variables start with `@` or `$` in Perl) which made this difficult.
Hopefully file names are okay as an output format because I'm pretty sure every other way to output information uses one of the banned characters.
[Answer]
# MATLAB, 36 bytes
SO CLOSE.... Only 1 byte more than the current winner (isaacg)! Which, on further inspection, already did what I set out to do too. Well, no harm in reinventing the wheel...
I know this is an old challenge, but I only realized that *after* I got interested in it.
```
['*+,-7;=?GHIKVWXYhiklnvwx'-7,57,'']
```
If only I could get MATLAB to understand that I want a string without a separate `''`...
 suggestions, anyone?
[Answer]
# Brainfuck 303 275
```
++++++++[>+>++>+++>++++>+++++>++++++>+++++++>++++++++>+++++++++>++++++++++>+++++++++++>++++++++++++>+++++++++++++>++++++++++++++>+++++++++++++++>++++++++++++++++<<<<<<<<<<<<<<<<-]>>>>+++.--->----.+.+.++>.>----.++.++.+.->.+.+.-->----.++++>-.+.+.+.-->>+.+.-->----.+.++.+>-.+.+.
```
Brainfuck, the ultimate unholed esoteric language (apart from Whitespace) ;)
[Answer]
# JS - 196 - [try it](http://jsfiddle.net/3H9FZ/)
```
h=(c=!1+[])[1];i=c[2*2];j=(f=[]+{})[1];this[i+'v'+h+'l'](h+'l'+i+'rt('+h+'t'+j+f[2]+'("Iy\x51lJj\\x'+2*2+'1\\x3'+~-1+'Nj\\x'+2*3+'75\x51EFC\x52E\\x3'+3*3+'\x51UVJhYm\x52lZ2\\x3'+3*3+'wc\x51=="))')
```
[Answer]
# GolfScript, 89 characters
```
71 22+,{33+}/]''+'!"\'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}'-
```
Simply builds an array of all ASCII characters and subtracts the non-"holed" characters from them.
```
71 22+,  # Builds array of 0..93
{33+}/]  # Converts to 33..126
''+      # Convert ASCII codes to string
'stuff'- # Subtracts "stuff" (the non-holed characters) from the string
```
[Answer]
# Befunge 98 - 69 bytes
```
"()+ijWI=*">:5j2 ,-5_"157:h">:5j2 ,-1_"=>?LMN^_lmn">:5j2 ,+3_"?"1+s <
```
Does it in 3 parts. One where unholed character values differ from holed character by 5. Then the ones that differ by 1, and finally a list of unholed characters that differ by 3 from holed ones. The terminate program instruction in Befunge is "@" (char value 64), so at the end I load "?" (char value 63) add 1 then put that in the code with the instruction 's'.
I could maybe golf it more by consolidating the three
```
>:5j2 ,(differ value)_
```
section, but probably not by much.
[Answer]
# Main - [Insomnia](http://esolangs.org/wiki/Insomnia), 50
```
FFy~~jF~y<={*n<<ztf>={.f=(tHL~k<yf={*n>Lj(FunLn<j~
```
It outputs:
```
abdegopq04689@ABDOPQR#$%&
```
# Bonus - Insomnia, 268
```
ogeeoddp@poe@ggep@oe@opge@gee@%d@p@gqeo@p@ge@e9de49ed9e4dppe@%e@geee@ge@p%ee@%e@dp@%ep@%ee@%d@%eeee@%e@%ee@%e@geee@%e@gee@ggopop@peo@ggep@p@ge@ggeep@ge@gee@%e@geee@ge@gee@ge@ppoep@%ee@%edep@gepe@ge@%ee@%e@geee@ge@%ee@%%eeoe@ge@pep@%gep@p@%e@%%eep@%e@gee@e%e@oe@%gep@p@
```
It outputs:
```
!"'()*+,-./12357:;<=>?CEFGHIJKLMNSTUVWXYZ[\]^_`cfhijklmnrstuvwxyz{|}~
```
I think it should be possible to reduce the length of the program if the output is rearranged, but I need to modify my search program to do this.
Just to show case another language which is capable of operate with a restricted number of characters. By the way, it can write just about any output with only 3 unique characters in the source.
Currently, this is the only language that can do both the main challenge and the bonus among all the existing answers.
[**Insomnia Interpreter**](https://codegolf.stackexchange.com/questions/40073/making-future-posts-runnable-online-with-stack-snippets/41868#41868).
[Answer]
# Befunge 98 - 46 bytes
Befunge-ified version of isaacg's Pyth entry:
```
"xwvnlkihYXWVKIHG?=;7-,+*">:5j2 ,-7_"?"1+:,s <
```
[Answer]
# JavaScript 240 228
Initial submission:
`z=(!1+"")[1];y=(!!1+"")[3];x={}+"";w=x[1];v=x[2];u=z+"t"+w+v;1[_="c\157nstruct\157r"][_](z+'l'+y+'rt('+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')()`
Now, this is a great start, here's how it breaks down...
```
z=(!1+"")[1];        // assigns "a" to z, !1+"" === "false"
y=(!!1+"")[3];       // assigns "e" to y, !!1 === "true"
x={}+"";             // assigns "[object Object]" to x
w=x[1];v=x[2]        // assigns "o" to w, and "b" to v
u=z+"t"+w+v;         // creates the mystical "atob" command, yes, I'm gonna use it!
1[_="c\157nstruct\157r"][_] // sets up the primitive to a number object... this acts similar to the "window" primitive object so that I can play off functions...
z+'l'+y+'rt(         // starts creating an alert call
'+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')()
// Above line abuses atob command with a couple of nested instances of the command, also using hex and octal equivalents of characters
```
And then I thought... "There must be a simpler way..." and there is...
Revised submission:
`z=(!1+"")[1];y=(!!1+"")[3];x={}+"";w=x[1];v=x[2];u=z+"t"+w+v;this[y+"v"+z+"l"](z+'l'+y+'rt('+u+'("Iy\x51lJj"+'+(t=u+'("\x51\x51==")')+'+'+u+'("M"+'+t+'+"==")+"Nj"+'+u+'("Zw==")+"5\x51EFC\x52E\71\x51UVJhYm\x52lZ2\71wc\x51=="))')`
Seeing I can use `eval` (by piecing it together, inspiration from @bebe; which is a lot quicker than using the `constructor` of a `constructor` of a `number`... ) I drilled it down to 228... I know it may not win this particular Golf Challenge, but this is just my way of showing how much you can abuse JavaScript, and still get the desired result...
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 33 bytes
```
7+2+"*+,-7;=?GHIKVWXYhiklnvwx"c-7
```
[Try it online!](https://ethproductions.github.io/japt/?v=1.4.5&code=NysyKyIqKywtNzs9P0dISUtWV1hZaGlrbG52d3giYy03&input=)
Same algorithm as [isaacg's Pyth submission](https://codegolf.stackexchange.com/a/35312/78410), just happens to be shorter in Japt.
### How it works
```
7+2+"*+,-7;=?GHIKVWXYhiklnvwx"c-7
7+2           Obviously the number 9
    "..."c-7  Apply -7 on each char's charcode of this string
   +          String concatenation
```
Yes, it's JS, which is [one of the most abusable languages](https://codegolf.stackexchange.com/questions/35310/write-the-whole-of-the-holed-using-the-unholed#comment76692_35351), just shorter (and you don't need `alert` or `console.log` here).
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `s`, 33 bytes
```
`*+,-7;=?GHIKVWXYhiklnvwx`C7-57JC
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=s&code=%60*%2B%2C-7%3B%3D%3FGHIKVWXYhiklnvwx%60C7-57JC&inputs=&header=&footer=)
Uses the same (independently discovered) trick of subtracting 7 and putting a 9 on the end.
[Answer]
# [PHP](https://php.net/), 59 bytes
```
<?='MMMMMMMMMM:::::::::::::::'^"nihk}y{ut\r{x~ujkh[X^_]UJK";
```
[Try it online!](https://tio.run/##K8go@P/fxt5W3RcOrFCBepxSXmZGdm1ldWlJTFF1RV1pVnZGdERcfGyol7eS9f//AA "PHP – Try It Online")
## Explanation
Utilises the string-XOR operator (`^`) to build the desired string from non-holed letters, output via `<?=`.
[Verification for 59 bytes.](https://tio.run/##fZBNawIxEIbv@ytevOS0optMsq5bvbf0WChULckmErWo2C7dIu1f3ya6FMHie5jveQbG6Hfftk1jkR4wgd@9OZvW25Pv7/0eZVmCDToV4BVfgttMQVhh/zVccw2U0zs2Y@zxT0WRnCHDiIkzN0zgk8syoLhUBC56HSYLGOnkCDKXBsqqEZRRBCUGNkY5lAup1KGL7cpvvr@O9Uf/2PzU603H4JGRkwHl5EBLsiASGsKE2zzsXcq/PC9e50/3D70xGyefFdLq@l9J/NlVtW1/AQ "Bash – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 72 bytes
```
*_=*~;("*,*E'syswrit\LE"^icx)->(uc,':=<?)-/! YX[]VIHKx{}|~vih'^(F^_)x25)
```
[Try it online!](https://tio.run/##K0gtyjH9/18r3larzlpDSUtHy1W9uLK4vCizJMbHVSkuM7lCU9dOozRZR93K1sZeU1dfUSEyIjo2zNPDu6K6tqauLDNDPU7DLS5es8LIVPP/fwA "Perl 5 – Try It Online")
## Explanation
I know this is longer than the existing Perl answer, but this outputs using STDOUT, rather than a filename.
`*_=*~` aliases the `~` variables (`@`, `%`, and `$`) into `_`, meaning that `$*` (which is `STDOUT` by default) is now in `$_`, which we can access using `uc` (which returns `$_` by default if no arguments are passed). Next the string `CORE::syswrite` is built from a combination of the stringwise-XOR of the two strings and the in-line lowercase modifier (`\L`) of `E`, which is then called as a function `->(`...`)` with the arguments `STDOUT` (from `uc`) and the desired string, also built via stringwise-XOR (copied from [@hmatt1's answer](https://codegolf.stackexchange.com/a/35358/9365) and amended to to save bytes using more stringwise-XOR).
[Answer]
# PICO-8, 196 bytes
```
c=77+2?"\35\37\52\57\111\112\113\71"..chr(33+3)..chr(31+7)..chr(32*2)..chr(72-7)..chr(71-5)..chr(71-3)..chr(71-2)..chr(c)..chr(c+1)..chr(c+2)..chr(75+22)..chr(75+23)..chr(c+21)..chr(57*2)..2*13*31
```
More variables like `c` might reduce size, not in the mood to try more at the moment.
]