[Question]
      [
Your task is to build a program (using only printable ASCII characters and/or tabs and newlines) that prints out exactly the characters in the printable ASCII space (`0x20` to `0x7e`) that *don't* appear in your program's source code (in any order, however many times you want).
The shortest code to do this in any language wins.

[Answer]
# [R](https://www.r-project.org/), 72 bytes
```
cat(intToUtf8(setdiff(32:126,utf8ToInt("\\\"(),12368:ITUacdefinostu"))))
```
[Try it online!](https://tio.run/##DcgxDgAREADAv6hWokEi4gd6Oo1gEw3JWe/fM@V8zK0SzEVpZ0IPZ1CfiGBN0Map@y7tuAhEKUWAVNpY50NMubY@cK596Ar5MP8 "R – Try It Online")
With correction from @JayCe
[Answer]
# [Ink](https://github.com/inkle/ink), ~~91~~ 86 bytes
```
{POW(77,7)} /*-#!"$%&'9:;<=>?@ABCDFGHIJKLMNQRSTUVXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~
```
[Try it online!](https://tio.run/##y8zL/v@/OsA/XMPcXMdcs1ZBX0tXWVFJRVVN3dLK2sbWzt7B0cnZxc3dw9PL28fXLzAoOCQ0LCIyKjomNi4@ITEpOSU1LT0jMys7Jzcvv6CwqLiktKy8orKqpu7/fwA "ink – Try It Online")
Prints `1.604852E+13`
The only thing Ink can really *do* to a string is print it - if you want to do actual string processing, you're meant to hook into external code. This means almost all characters will have to occur in our code, since we generally have no way to print the ones that don't. That means we can basically treat the first occurrence of each character as being free, and see how much stuff we can generate with as few *repeated* characters as possible.
One thing Ink *can* do is math. We can generate and print a number. With only two repeated characters, the expression `{POW(77,7)}` becomes `1.604852E+13`, which has eleven distinct characters, none of which are used in the expression.
At this point, there isn't much more we could generate. We need `7` in our code, and while we might be able to generate a `-`, we'd need another set of `{}` to do more math, so that would really be a net negative. So we begin a multi-line comment using `/*` (because Ink doesn't care if we ever close those) and shove all the rest of the characters we aren't using in there.
* `-5 bytes` by creating a larger floating-point number using `POW` instead of `FLOAT`, which then also includes `E` and `+` and has fewer repeated characters
[Answer]
# J - 21
```
(u:32+i.97)-.1!:1<":5
```
write this to a file called `5` in the current directory. Then load execute the script with `0!:1<'5'`
Or 25 without the file trick:
```
(-.~".)'(":u:32+i.0-~95)'
```
[Answer]
**Clojure (~~142, 106~~, 103)**
```
(defn -main[](let[c"(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]((load-string c)c)))
```
formatted:
```
(defn -main []
  (let [c "(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]
    ((load-string c) c)))
```
Think this does it, may need some tweaks.
output:
```
#{@ ` ! A B b # C $ D % E & F ' G H I * J + K k , L M . N / O 0 P Q q R S 4 T 5 U V v 7 W w 8 X x 9 Y y : Z z { < | = } > ^ ? _}
```
runs the string, which is evaluateable clojure code, on itself. String has some comments at the end to get the characters used outside of the string (main method, etc)
[Answer]
# [Cubically](https://github.com/aaronryank/cubically), 61 bytes
### Code:
```
~:5+1-777(B1D1+7)6+33077777(D3B3@6-7)0&2 !"#$%'*,./489;<=>?AC
```
### Unique characters in program:
```
 !"#$%&'()*+,-./0123456789:;<=>?@ABCD~
```
### Output:
```
EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
```
[Answer]
# Python 2, 68 ~~83~~ ~~88~~ (but it actually reads the file)
No comments, no hacks, it just opens itself, and checks the contents. Includes the set logic from [this answer](https://codegolf.stackexchange.com/a/12375).
```
print"".join(set(map(chr,range(32,127)))-set(open(__file__).read()))
```
Changed to print the output and not an array.
[Answer]
## Bash (pure), ~~93~~ ~~92~~ 88 bytes
```
eval "a=$'$(printf '\\x%x' {32..127})'"
while read -rn1 c;do a=${a/"$c"};done<$0
echo $a
```
### Example
```
cat > foo.sh # now paste and C-d
bash foo.sh  # !#&*+,45689:>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]^_`bgjkmqsuyz|~
wc -c foo.sh # 93 (including end-of-line \n)
```
### Explanation
* The `eval` thing: construct a string that looks like `\x20\x21...\x7f`, and use bash&ksh's c-style-quote `$'c-escape-str'` to wrap it, in order to escape it into some real list-of-chars.
* Then we use a while loop to read chars one-by-one, and use the 'replace first occurance' `${var/pat}` to kill corresponding chars in `$a`.
Note that we didn't set `IFS` properly, and `read` by default will consume `\x20`, `\n` and `\t`. The `\x20` part will be handled later.
* Finally we abuse IFS again so it can eat the space.
The output is in ASCII char order.
This very literal (for code golfs at least) one actually ended up smaller than what I expected it to be. Otherwise I will be thinking about `# !&*+abc....`
[Answer]
# [Z80Golf](https://github.com/lynn/z80golf), 83 bytes
```
00000000: 2b2b 7036 092e 452c 453b 3b78 6f2c 4523  ++p6..E,E;;xo,E#
00000010: 2323 2323 2323 2323 2323 2323 2323 2329  ###############)
00000020: 2929 2929 2929 2929 307e 7620 2122 2425  ))))))))0~v !"$%
00000030: 2627 282a 2d2f 3132 3334 3537 3839 3a3c  &'(*-/12345789:<
00000040: 3d3e 3f40 4142 4344 7172 7374 7577 797a  =>?@ABCDqrstuwyz
00000050: 7b7c 7d                                  {|}
```
[Try it online!](https://tio.run/##hczJTsNAEATQO19REAiEhDDTNeO2EwgQ8Id45YIU9iUsv27GMBe4pA6lbqn01qm5Xt20XWdiZpBSSqhhApNJA@elCsUSLDVF0v68QmA8vk2m03ySz@evq0k@2PoVbG8wDDZWBgz@ZhQN6Y0sDP4VjTbQRAzEikCceGAUY76esb2zuxcN9kYiCkmlgNTSgpYCkg70VDBlIAtWwHD/4PDo2Aqd1zSbnUTDBYM1G7B1Bs46gaNzUKsCpYbLq0IzLYDTxdn5xfLy6u7@4fHp5W0dDR8MLbWC1tiY94/PrvsG "Z80Golf – Try It Online")
Printable characters aren't *too* useful in z80, but we can write this:
```
   dec hl
   dec hl
   ld (hl),b
   ld (hl),9
   ld l,'E'
   inc l
   ld b,l
   dec sp      ; $0009 starts here
   dec sp
   ld a,b
   ld l,a
   inc l
   ld b,l
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   inc hl
   add hl,hl
   add hl,hl
   add hl,hl
   add hl,hl
   add hl,hl
   add hl,hl
   add hl,hl
   add hl,hl
   add hl,hl
   jr nc, $+2+'~'
   halt
   db " !\"$%&'(*-/12345789:<=>?@ABCDqrstuwyz{|}"
```
The idea is to print characters from `'F'` to `'n'`, and put all the remaining characters in the code (the "garbage" string at the end).
The preamble writes `09` (tab) to `$fffe`, so that we can point SP there to jump to `$0009` after putchar. The `ld (hl), b` achieves nothing; I just get rid of `'p'` there.
`L` is initialized to `'E'+1`, and counts up until `(HL+17) << 9` overflows (sets the carry), which is when `L` is 111 = `'o'`, the first character we don't want to print.
If the carry is *not* set, we jump over a halt instruction and the garbage string, into thousands of NOPs, the PC eventually running into `putchar = $8000` and returning to `$0009`.
See [this answer](https://codegolf.stackexchange.com/a/166951/3852) for some more info on how this code prints characters in the first place.
[Answer]
# [Deadfish~](https://github.com/TryItOnline/deadfish-), ~~70~~ ~~55~~ 51 bytes
```
{iii}i{icicicicicic}dd{ci}iicicicici{ic}dd{ci}iciic
```
Because, y'know, I'm hilarious and original.
*Saved 15 bytes by repeating a few characters*
*Saved 4 more by simplifying both instances of*  `d{ic}i` *to* `{ci}`
[Try it online!](https://tio.run/##S0lNTEnLLM7Q/f@/OjMzszazOjMZAWtTUqqTgYJwkWqEWDJQ9P9/AA "Deadfish~ – Try It Online")
**Previous Version (55 bytes):**
```
{iii}i{icicicicicic}ddd{ic}iiicicicici{ic}ddd{ic}iiciic
```
[Answer]
# Brainfuck, 95 bytes
```
[ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmnopqrstuvwxyz{|}~]
```
The way this works is pretty simple, any decent Brainfuck interpreter will ignore the code between the brackets appearing at the start of source file, therefore creating a comment.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 20 bytes
```
PARM`[\\APRM\`\]\[]`
```
Uses the predefined printable ASCII variable, and regexes out the letters in the code.
[Try it online!](https://tio.run/##K8gs@P8/wDHINyE6JsYxIMg3JiEmNiY6NuH/fwA "Pip – Try It Online")
[Answer]
# Q, 44
```
-1"c"$til[128]except"i"$"-1\"c$til[28]exp;";
```
.
```
q)-1"c"$til[128]except"i"$"-1\"c$til[28]exp;";
345679:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abdfghjkmnoqrsuvwyz{|}
```
[Answer]
**C++ 143**
```
#include<fstream>
#include<iostream>
char c[256],d,e=32;int main(){for(std::fstream i(__FILE__);i>>d;)c[d]++;for(;++e<127;)c[e]||std::cout<<e;}
```
**Alternative version using macros - 155**
```
#include"iostream"
#define d int main(){while(s,*s)l[*s++]++;for(e=35;++e<127;)!l[e]&&std::cout<<e;}
#define t(a)#a
#define f(a)t(a)
char*s=f(d),l[257],e;d
```
**And a version without 'reflection' (examining own source) - 139**
```
#include"iostream"
char h['~'],*a="'()*+,:;<=[]acdefhilmnorstu{}",i='#';int main(){for(;*a;)h[*a++]++;for(;++i<'~';)if(!h[i])std::cout<<i;}
```
[Answer]
# Bash, with coreutils, 80
```
p=printf
for o in {32..126};{
c=`$p $($p "\%o" $o)`
grep -qF "$c" $0||$p "$c"
}
```
Output is:
```
!#&'}+,/45789:<>}@ABCDEGHIJKLMNOPQRSTUVWXYZ[]^_abhjklmsuvwxyz~
```
[Answer]
# PowerShell, 75 bytes
```
[char[]](32..39+42+44+45+47+58..90+92+94..96+98+100..103+105..113+115..126)
```
A different approach than the [other PowerShell answer](https://codegolf.stackexchange.com/a/15374/42963). Here, we manually build a list of ASCII values `(...)` that aren't in the source code, then cast that as a char-array `[char[]]`. PowerShell will by default write out values alone on a line like this, so we get printing for free.
Characters used in code: `()+.0123456789[]achr`
[Answer]
## Marbelous, 111 bytes
```
@0
--7E
<XE\
../\@0
:E\
}0}0
&0&1
{0{>
}0
-F
-E
-5
-4
>0
-7
>D
-F
>0
-2
>0
-2
>0
-3
>3
-2
-6
-8
-9
>0
&0&1
\/\/
```
Main board loops from 0x7E down to 0x20, E\ function rejects values by decrementing and comparing to small numbers (Marbelous' built in < and > operators only work on the range 0-35).
[Answer]
# Python 2, 62
```
from string import*;print set(printable)-set(open("p").read())
```

Code must be saved in a file called `p`.
Lowest python solution so far ;D
[Answer]
## Bash internals only, 133 bytes
```
w=printf
while IFS= read -r -n1 r;do i[$($w %d \'$r)]=1;done<$0
for r in {33..126};do [[ 1 -ne ${i[$r]} ]]&& $w \\$($w "%o" $r);done
```
Save and run with `bash <filename>`
### Explanation
1. Make `printf` shorter.
2. For each char `r` read from `$0` (i.e. the script itself), set `i[ord(r)]` to 1.
3. For each number `r` in `range(33, 127)`, if `i[r]` is not `1`, `printf` the char corresponding to the number `r`. The `$w \\$($w "%o" $r)` part is where the number-to-char magic is: convert the number to OCT, and then prepend a backslash, and finally feed to `printf` to really print it.
The output is in ASCII order.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 33 bytes
```
157 255B'QJ.V"157 2B'QJ.VSK"SK'"K
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f0NRcwcjU1Ek90EsvTAnMg7CDvZWCvdWVvP//BwA "05AB1E – Try It Online")
---
Pushes `žQ` by converting 157 into base 255.
Executes `žQ` with `.V` which pushes the printable ASCII character set (32-128).
Then remove all characters in the source code using `K`.
[Answer]
# [Memory GAP](https://github.com/ConorOBrien-Foxx/memory-GAP), 3104 bytes
```
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
```
[Try it online!](https://tio.run/##7VZLrhwxCDxRJLDBwHEwmKyeEmWX00@YE/Si1Zos3q7VmHJB8fHX@fr15@@Pn/779RLaKnMKMQ2ApJyzFILWmhl8uGTngi28h6XYXgt8KNs0DvRBcKzw6CHYW@wowIYIozl1QhRNOiFa/QurNh6mSOVDDjb60Pjf/SVOqcskZRaRGG4J4UVjrXWW7YFewVSbNJFnoCHgYi3y4aRX@HftbNR6zT0VnHDaOvlWzlsfmK3pXf2etl/pc9d@936SHYdDqFitSJfkTpZj4daJ16v8Ps3/Sv@78d@Nry/DdraAwr1cJ8Y0O2OZSLcQXuHXoBiBjZAwxSSWCpk2UqIxrkv@XtBInOVJnF6JFWMm45hLeRY4ZmWsZtCf5IvArMQD4xyd3/Pxs/19t36e7q@791/V5@P9dVH/d/vv7v50lTwbMLh42lk7vbGGhZ56Z6j5DEFvTXIHvaMH2WdLDsO2sHLT0ISxAlD7RJsNO8hV1s7jHUxDI7Inkg1sgtgzvlmfUMDL/f7h@vyeT8/Op9vvBxy0A9zm5BhSoKtbavsAcTIcn95/V/X/ev0D "Memory GAP – Try It Online")
Expanded:
```
74b87337454200d4d33f80c4663dc5e5f7bd60b75b29d79b660a2859395c1a240e9f1e8e40bb79e8
00b0cc9433830cf434ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf4
34ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf434ec78fcc91ffb1e
54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf47cef8a734855777c2a9d0caf42666e69
b21afc54fb48d153c19101658f4a2a480e9f1e8e40bb79e800b0cc9433830cf40e9f1e8e40bb79e8
00b0cc9433830cf40e9f1e8e40bb79e800b0cc9433830cf4594f803b380a41396ed63dca39503542
f7bd60b75b29d79b660a2859395c1a240e9f1e8e40bb79e800b0cc9433830cf40e9f1e8e40bb79e8
00b0cc9433830cf40e9f1e8e40bb79e800b0cc9433830cf40e9f1e8e40bb79e800b0cc9433830cf4
34ec78fcc91ffb1e54cd85e4a092433234ec78fcc91ffb1e54cd85e4a092433234ec78fcc91ffb1e
54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf434ec78fcc91ffb1e54cd85e4a0924332
47bce5c74f589f4867dbd57e9ca9f808f7bd60b75b29d79b660a2859395c1a2434ec78fcc91ffb1e
54cd85e4a092433234ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf4
594f803b380a41396ed63dca395035420e9f1e8e40bb79e800b0cc9433830cf434ec78fcc91ffb1e
54cd85e4a0924332f7bd60b75b29d79b660a2859395c1a2434ec78fcc91ffb1e54cd85e4a0924332
0cc175b9c0f1b6a831c399e269772661f7bd60b75b29d79b660a2859395c1a24f24c2c15b9d03797
c6874986a8d1951634ec78fcc91ffb1e54cd85e4a0924332faf05c15dfad45dafd1fc23d51236853
f0a1dfdc675b0a14a64099f7ac1cee8374b87337454200d4d33f80c4663dc5e5f7bd60b75b29d79b
660a2859395c1a240e9f1e8e40bb79e800b0cc9433830cf434ec78fcc91ffb1e54cd85e4a0924332
0e9f1e8e40bb79e800b0cc9433830cf434ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e8
00b0cc9433830cf434ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf4
0e9f1e8e40bb79e800b0cc9433830cf434ec78fcc91ffb1e54cd85e4a092433234ec78fcc91ffb1e
54cd85e4a09243320cc175b9c0f1b6a831c399e269772661f7bd60b75b29d79b660a2859395c1a24
34ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf4594f803b380a4139
6ed63dca39503542f7bd60b75b29d79b660a2859395c1a2434ec78fcc91ffb1e54cd85e4a0924332
faf05c15dfad45dafd1fc23d5123685334ec78fcc91ffb1e54cd85e4a09243320cc175b9c0f1b6a8
31c399e269772661f7bd60b75b29d79b660a2859395c1a24f0a1dfdc675b0a14a64099f7ac1cee83
f24c2c15b9d03797c6874986a8d1951634ec78fcc91ffb1e54cd85e4a09243327cef8a734855777c
2a9d0caf42666e69b21afc54fb48d153c19101658f4a2a48a87deb01c5f539e6bda34829c8ef2368
c68271a63ddbc431c307beb7d2918275852438d026c018c4307b916406f98c6274985f5115ad1492
12a917dbef8ec801b21afc54fb48d153c19101658f4a2a480cc175b9c0f1b6a831c399e269772661
f7bd60b75b29d79b660a2859395c1a2434ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e8
00b0cc9433830cf474b87337454200d4d33f80c4663dc5e5f7bd60b75b29d79b660a2859395c1a24
0e9f1e8e40bb79e800b0cc9433830cf434ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e8
00b0cc9433830cf434ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf4
34ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf40e9f1e8e40bb79e8
00b0cc9433830cf434ec78fcc91ffb1e54cd85e4a09243320e9f1e8e40bb79e800b0cc9433830cf4
34ec78fcc91ffb1e54cd85e4a09243324124bc0a9335c27f086f24ba207a4912f7bd60b75b29d79b
660a2859395c1a24f24c2c15b9d03797c6874986a8d1951634ec78fcc91ffb1e54cd85e4a0924332
faf05c15dfad45dafd1fc23d5123685374985f5115ad149212a917dbef8ec801
```
## Explanation
Memory GAP's instructions are md5 hashes of their *actual* instructions. Using `;` as a delimiter, this is the "original" program:
```
;
aaaa;size;dup;add;dup;add;dup;add;
dup;open;pop;
dup;
dup;
dup;
aaaaa;size;dup;dup;dup;dup;add;add;add;dup;add;aaa;size;add;add;dup;aaaaa;dup;add;size;add;a;size;neg;add;
btwn;
swap;
aaaa;size;dup;add;dup;add;dup;add;dup;dup;add;add;a;size;add;dup;aaaaa;size;add;btwn;
add;
a;size;swap;neg;add;
open;
pop;char;out;nil;shut;pop;
a;size;add;
dup;
aaaa;size;dup;add;dup;add;dup;add;
dup;dup;add;dup;add;aa;size;neg;add;btwn;
shut;
```
This simply iterates over the range between 32 and 126, and prints it if and only if it does not fall between `'0'` and `'9'` or `'a'` and `'f'`.
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~83~~ 79 bytes
```
120d115 108 100 93 91 80 62[d1-d43<:]ds:x[l.dP]s;34s.[dl.!=;s,l.1+ds.127>/]ds/x
```
[Try it online!](https://tio.run/##DcotGoAgDADQq8yszg1Q@VHPYOcjuUhb4fZIeO3J1zsbEuYdmPxAECwEBk9wmCy8irNXLKKx5YryFk3WKWapON1Jl4o8iyKb89nG2lrvPw "dc – Try It Online")
Prints `"#$%&'()*?@ABCDEFGHIJKLMNOQRSTUVWXYZ\^_`abcefghijkmnopqrtuvwyz{|}~`
The lazy answer of commenting out the entire printable range (and printing nothing) would be 95 bytes, so while this may be suboptimal, I'm pretty pleased.
`120d115 108 100 93 91 80 62[d1-d43<:]ds:x` puts all the values on the stack that we need to ignore. Decimal is seemingly the ideal base for this, particularly when I factor in the additional characters that would be needed to change the input base. The first few values I have to enter in manually, but I use all the characters from 43-62, so I can generate those in a loop. I don't need to use a few of these characters, but it saves bytes to run through the ones that I don't need, so I named my registers/macros `:`, `.`, `,`, `;`, and `/` for the sake of using those characters.
`[l.dP]s;` is the macro that will print the character if it's not in the list. `34s.` is the counter - since I use characters 32 and 33, I just start at 34. `[dl.!=;s,l.1+ds.127>/]ds/x` is a pretty straightforward macro, just load the counter, `.`, see if it's in the list, run `;` if so, increment, and loop until we're out of printable range.
Golfed off four bytes because I was accidentally omitting `p` (this also made my answer invalid!). I must have at one point used both `P` and `p` to print, or thought I would have to.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 43 bytes
```
<say |keys (" "..<~>) (-).comb#EVAL>~~.EVAL
```
[Try it online!](https://tio.run/##K0gtyjH7/9@mOLFSoSY7tbJYQUNJQUlPz6bOTlNBQ1dTLzk/N0nZNczRx66uTg9E//8PAA "Perl 6 – Try It Online")
Uses the standard Perl6 quine format.
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 41 bytes
```
"lops!;=`][' "s'"ll[p'~=[;]p~![!lo]pl`sl]
```
[Try it online!](https://tio.run/##y6n8/18pJ7@gWNHaNiE2Wl1BqVhdKScnukC9zjbaOragTjFaMSc/tiAnoTgn9v9/AA "Ly – Try It Online")
This one just pushes all the unique characters used in the code (minus `~` to the stack, along with `"`) then iterates from the codepoint for  (space) checking to see if that codepoint is on the stack. Any codepoint that isn't found is printed.
```
"lops!;=`][' "                            - loads all the used chars to the stack
              s                           - save ` ` (space) to backup cell
               '"                         - add `"` to the stack too
                 ll                       - load the curr codepoint twice
                   [p                  l] - infinite loop
                     '~=[;]p              - if the code point is `~` exit
                            ~              - search stack for curr codepoint
                             !             - negate results boolean
                              [!  ]p       - if/then, true if not found
                                lo         - restore curr codepoint and print
                                    l`s    - restore curr codepoint and increment

```
Output is:
`#$%&()*+,-./0123456789<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_abcdefghijkmnqrtuvwxyz{|}`
[Answer]
# [JSFuck](https://github.com/aemkei/jsfuck) 11863
This answer is a compressed version of [this code](https://codegolf.stackexchange.com/a/12734/88163)
```
for(x=0x7e;x>0x19;x--){console.log(String.fromCharCode(x).replace(/[\[\]!\+\(\)]/ig,''))}
```
here is the full working JSFuck version of this code
```
[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(+(!+[]+!+[]+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][[]]+[])[+!+[]]+(![]+[])[+!+[]]+((+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]]](!+[]+!+[]+!+[]+[!+[]+!+[]])+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]])()([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]]+((![]+[])[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+(![]+[])[+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(![]+[])[+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+([][[]]+[])[!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]]+(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]]+(!![]+[])[+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]]+[+!+[]]+(!![]+[])[+[]]+[+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[!+[]+!+[]+!+[]+!+[]+!+[]])[(![]+[])[!+[]+!+[]+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][[]]+[])[+!+[]]+(![]+[])[+!+[]]+((+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]]((!![]+[])[+[]])[([][(!![]+[])[!+[]+!+[]+!+[]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]](([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]]+![]+(![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]])()[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((![]+[+[]])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+!+[]+[+[]]])+[])[+!+[]])+([]+[])[(![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(!![]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]()[+!+[]+[!+[]+!+[]]])())
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 12 bytes
```
Vp.."-"Vp-"-
```
[Run and debug online!](https://staxlang.xyz/#c=Vp..%22-%22Vp-%22-&i=&a=1)
Added for completeness.
`Vp` in Stax is the set of all printable ASCII characters, `.."` is the two character string literal (of `."`) in Stax.
[Answer]
# Ruby (50)
```
puts (?#..?~).to_a.join.tr"()?!#.,~_aijnoprstu",""
```
Outputs:
```
$%&'*+-/0123456789:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^`bcdefghklmqvwxyz{|}
```
[Answer]
## Python, 94
```
print !"#$%&'90*+,-.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/\]^_`abcdefghjklmoqsuvwxyz{|}
```
[Answer]
# Ruby 2.1.0
## ~~206~~ 204 characters
```
chars_in_source = File.read("self.rb").chars.uniq.map(&:ord)
printable_ascii = (20..126).to_a
not_in_source = printable_ascii.reject { |c| chars_in_source.include?(c) }
puts not_in_source.map(&:chr).join
```
And the output is:
```
#$%'*+,-/345789;<>@ABCDEGHIJKLMNOPQRSTUVWXYZ[\]^`gkvwxyz~
```
Not the shortest here (in fact, it might be the longest). But that's the great thing about this: it got me to go try something I'd never done before.
[Answer]
# Python, 88 81 78 77 bytes
## actually reads the file
I tried to do it the 'clean' (as in 'easy to read') way, turned out quite nice, although i'm still new to python and probably this can be shortened as well.
file named 'a' is the file executed.
```
from string import*
for c in printable:
    if c not in open('a').read():print c
```
And it prints out all the ASCII characters not found in source file. I know this was supposed to be a clever hack (as in all those which contain all the ascii set or addresses, or use an error), but I wanted to do explicitly what was asked :]
Anyone has a suggestion how to make it even shorter while still going in this direction?
[edit] trimmed one more char, thanks for the tip!
[Answer]
### Javascript 78 chars
```
bghjklm()seuABCDEFGHIJKLMNOPQRSTUVWXYZvwyz!@#$%^&*1234567890{}[]-=_+\;"'.,<>/?
```
Outputs:
```
SyntaxError: Unexpected identifier
```
Not the shortest code, but threw a try for fun. Notice the colon (`:`) and space () are covered in Output also.
Feedback appreciated.
]


[Question]
      [
It's a common problem to navigate in a 2D matrix. We've seen it many times and will see again. So let's help future us and develop the shortest solutions to generate all eight possible steps in a 2D matrix.
## Challenge
Your code must output the following 8 pairs of -1,0,1 in any order:
```
(0,1)
(0,-1)
(1,0)
(-1,0)
(1,1)
(1,-1)
(-1,1)
(-1,-1)
```
## Rules
1. There is no input.
2. Output order is not relevant
3. Output is flexible. Pairs of numbers just need to be distinguishable
4. This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins

[Answer]
# [Octave](https://www.gnu.org/software/octave/), 24 bytes
```
dec2base([0:3,5:8],3)-49
```
[Try it online!](https://tio.run/##y08uSSxL/f8/JTXZKCmxOFUj2sDKWMfUyiJWx1hT18Ty/38A "Octave – Try It Online")
I haven't seen this approach yet.
Creates a list of integers `[0, 1, 2, 3, 5, 6, 7, 8]`, and converts it to ternary, returning a character array:
```
00
01
02
10
12
20
21
22
```
Subtracting `49` (ASCII-value for `1`) from all characters gives a numeric array:
```
-1  -1
-1   0
-1   1
 0  -1
 0   1
 1  -1
 1   0
 1   1
```
[Answer]
# Pure [Bash](https://www.gnu.org/software/bash/) (no external utilities), 36
```
a=({0,-1,1},{0,-1,1})
echo ${a[@]:1}
```
[Try it online!](https://tio.run/##S0oszvj/P9FWo9pAR9dQx7BWB8bQ5EpNzshXUKlOjHaItTKs/f8fAA "Bash – Try It Online")
---
# [Bash](https://www.gnu.org/software/bash/) with Sed, 35
```
printf %s\\n {-1..1},{-1..1}|sed 5d
```
[Try it online!](https://tio.run/##S0oszvj/v6AoM68kTUG1OCYmT6Fa11BPz7BWB0rXFKemKJim/P8PAA "Bash – Try It Online")
[Answer]
# T-SQL, ~~80~~ 78 bytes
```
SELECT-1n INTO t;INSERT t VALUES(0),(1)SELECT*FROM t,t z WHERE t.n<>0OR z.n<>0
```
Creates a (permanent) table **t** containing `(-1,0,1)`, and performs a self-join with a `WHERE` clause that excludes the `0,0` row. The table **t** is not cleaned up by my code, you must drop it yourself.
Sadly nearly twice as long as the boring solution (**44 bytes**), since SQL allows returns in strings:
```
PRINT'0,1
0,-1
1,0
-1,0
1,1
1,-1
-1,1
-1,-1'
```
[Answer]
# [Python 2](https://docs.python.org/2/), 33 bytes
```
i=9;exec"print-i%3-1,i/5;i-=2;"*8
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PW0jq1IjVZqaAoM69EN1PVWNdQJ1Pf1DpT19bIWknL4v9/AA "Python 2 – Try It Online")
Dennis saved ~~3~~ 5 bytes, wow. Thanks!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~8~~ ~~7~~ 6 bytes
```
3p_2ẸƇ
```
[Try it online!](https://tio.run/##y0rNyan8/9@4IN7o4a4dx9r//wcA "Jelly – Try It Online")
My first ever Jelly answer! Much thanks to Dennis for the final piece of the puzzle.
Now, let's see if I can explain it ... lol.
```
3p_2ẸƇ   Main program, takes no input.
3p       Product with Range 3, yields [[1,1], [1,2], [1,3], [2,1], [2,2], ...]
  _2     Decrement twice, vectorizes, yields [[-1,-1], [-1,0], [-1,1], [0,-1], ...]
    ẸƇ   Comb, removes those that contain only falsey values, the [0,0]
         Implicit output
```
*-1 byte thanks to Erik; -1 byte thanks to Mr Xcoder and Dennis*
[Answer]
# [Haskell](https://www.haskell.org/), 22 bytes
```
_:l=mapM(:[1,-1])[0,0]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P94qxzY3scBXwyraUEfXMFYz2kDHIPZ/bmJmnm1BUWZeiULO/3/JaTmJ6cX/dZMLCgA "Haskell – Try It Online")
*Laikoni saved 1 byte.*
[Answer]
# [R](https://www.r-project.org/), ~~26~~ 24 bytes
Credits to @JDoe for saving two more bytes with a direct approach:
```
paste(-1:1,-3:5%/%3)[-5]
```
[Try it online!](https://tio.run/##K/r/vyCxuCRVQ9fQylBH19jKVFVf1VgzWtc09v9/AA "R – Try It Online")
The original asnwer:
```
outer(-1:1,-1:1,paste)[-5]
```
[Try it online!](https://tio.run/##K/r/P7@0JLVIQ9fQylAHTBQkFpekakbrmsb@/w8A "R – Try It Online")
Or for 27 bytes
```
sapply(-1:1,paste,-1:1)[-5]
```
[Try it online!](https://tio.run/##K/r/vzixoCCnUkPX0MpQpyCxuCRVB8TUjNY1jf3/HwA "R – Try It Online")
Or for 34 bytes with factors:
```
(gl(3,3,,-1:1):gl(3,1,9,-1:1))[-5]
```
[Try it online!](https://tio.run/##K/r/XyM9R8NYx1hHR9fQylDTCswz1LGEcDWjdU1j//8HAA "R – Try It Online")
This last solution might be the golfiest if the output could be from 1 to 3 rather than from -1 to 1.
See [the other R answer](https://codegolf.stackexchange.com/a/164763/80010) for alternate solutions with `expand.grid` or with `cbind`.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~13~~ ~~12~~ 11 bytes
*Saved a byte thanks to @Shaggy*
```
9ó8_ìJõ é)Å
```
[Try it online!](https://tio.run/##y0osKPn/3/LwZov4w2u8Dm9VOLxS83Dr//@6QQA "Japt – Try It Online") Uses `-R` flag to put each item on its own line.
### Explanation
```
9ó8_ìJõ é)Å
9ó8             Create the range [9, 9+8). [9, 10, ..., 16]
   _            Map each item in this range through this function:
     Jõ é)        Generate the range [-1...1] and rotate to get [1, -1, 0].
    ì             Convert the item to an array of base-3 digits,
                  mapping [0,1,2] to [1,-1,0]. [[-1, 1, 1], [-1, 1,-1], [-1, 1, 0],
                                                [-1,-1, 1], [-1,-1,-1], [-1,-1, 0],
                                                [-1, 0, 1], [-1, 0,-1]]
          Å       Remove the first item (gets rid of the leading -1).
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-Q`, ~~15~~ 13 bytes
I'm sure there's a shorter way, but I liked this approach.
```
##ü80ì3 mÉ ò
##ü80        // Take 14425280
     ì3      // and turn it into an array of base-3 numbers.
        mÉ   // Subtract one from each digit
           ò // and then split them pairwise.
```
Shaved off two bytes thanks to [Shaggy](https://codegolf.stackexchange.com/users/58974/shaggy).
[Try it online!](https://ethproductions.github.io/japt/?v=2.0a0&code=I5Aj/Dgw7DMgbckg8g==&input=LVE=)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 23 bytes
```
{(1,-1,0 X 1,-1,0)[^8]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/WsNQR9dQx0AhQgHC0IyOs4it/V@cWKmQpqFp/R8A "Perl 6 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~8~~ 7 bytes
```
2Ý<ãʒĀZ
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f6PBcm8OLT0060hD1/z8A "05AB1E – Try It Online")
**Explanation**
```
2Ý<     # Range of 2 decremented, yields [-1, 0, 1]
   ã    # Cartesian product of the list with itself
    ʒ   # Filter by ...
     ĀZ # Maximum of the truthified values, yields 0 only if both values are 0.
```
-1 byte thanks to Emigna !
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~7~~ 6 bytes
There are a lot of different ways (the tricky/costly part is getting rid of `[0,0]`), ~~7 bytes is the shortest I could come up~~ thanks to [Leo](https://codegolf.stackexchange.com/users/62393/leo?tab=profile) for pointing out to use decimal conversion (`d`) as a filter:
```
fdπ2ṡ1
```
[Try it online!](https://tio.run/##yygtzv7/Py3lfIPRw50LDf//BwA "Husk – Try It Online")
### Explanation
```
fdπ2ṡ1  -- constant function (expects no arguments)
    ṡ1  -- symmetric range [-n..n]: [-1,0,1]
  π2    -- cartesian power of 2: [[-1,-1],[-1,0],[0,-1],[-1,1],[0,0],[1,-1],[0,1],[1,0],[1,1]]
f       -- filter only elements that are truthy when
 d      -- | decimal conversion (interpret as polynomial and evaluate at x=10)
        -- : [[-1,-1],[-1,0],[0,-1],[-1,1],[1,-1],[0,1],[1,0],[1,1]]
```
---
## Alternative, 7 bytes
```
tπ2ṙ1ṡ1
```
[Try it online!](https://tio.run/##yygtzv7/v@R8g9HDnTMNH@5caPj/PwA "Husk – Try It Online")
### Explanation
```
tπ2ṙ1ṡ1  -- constant function (expects no arguments)
     ṡ1  -- symmetric range [-n..n]: [-1,0,1]
   ṙ1    -- rotate by 1: [0,1,-1]
 π2      -- cartesian power of 2: [[0,0],[0,1],[1,0],[0,-1],[1,1],[-1,0],[1,-1],[-1,1],[-1,-1]]
t        -- tail: [[0,1],[1,0],[0,-1],[1,1],[-1,0],[1,-1],[-1,1],[-1,-1]]
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 12 bytes
```
9:q4X-3YA49-
```
[Try it online!](https://tio.run/##y00syfn/39Kq0CRC1zjS0cRS9/9/AA "MATL – Try It Online")
Because it's MATL month, here's a MATL port of @Stewie's Octave answer. The sequence [0 1 2 3 5 6 7 8] is generated as the set difference between [0 ... 8] and 4.
[Answer]
# Java 8, ~~83~~ 42 bytes
```
v->"1,1 1,0 1,-1 0,1 0,-1 -1,1 -1,0 -1,-1"
```
-41 bytes thanks to *@AdmBorkBork* by hard-coding..
[Try it online.](https://tio.run/##LU5BCoMwELz3FYunCEbMWdof1IvQS@lhG22JjVHMGijFt6cbFHZgd4aZnQEDyqH7RG3Re7iicb8TgHHULy/UPTTpBGhpMe4NWtwm00HIa2Y3Bo8nJKOhAQdniEFeMlUoUEXFkAqqIoEXmWiZeJmELNa7f16flv1HTEj5I9cQ@8v7A/OjwtdTP5bTSuXMCglXauFWa/OjzRb/)
---
Non hard-coded version as reference (**~~83~~ ~~72~~ ~~70~~ 68 bytes**):
```
v->{for(int i=9;i-->1;)System.out.println(~i%3+1+","+(~(i/3)%3+1));}
```
-11 bytes thanks to *@OlivierGrégoire*.
-2 bytes creating a port of [*@ETHproductions*'s JavaScript (ES6) answer](https://codegolf.stackexchange.com/a/164797/52210).
[Try it online.](https://tio.run/##LY7BCoMwDIbve4owGLS4OsTTKPoG8yLsMnboqo66WsVWYYi@ehenkBD@hPz/V4tRsLr4eKmFtXATykwHAGVc2VdClpCtEmBsVQGS3NcxUo67GRvLOuGUhAwMJOBHlk5V2xP8B5VcuWIsjTjNv9aVTdgOLux6vGlDFnWKgyg4no8BWYi6xHTVlPLZ8825G14anfeAP0CDeCR3aPF@PAXd0EwoiRm03qlm/wM)
[Answer]
# [R](https://www.r-project.org/), 27 bytes
```
expand.grid(-1:1,-1:1)[-5,]
```
[Try it online!](https://tio.run/##K/r/P7WiIDEvRS@9KDNFQ9fQylAHRGhG65rqxP7/DwA "R – Try It Online")
30 and 35 bytes:
```
cbind(-1:1,rep(-1:1,e=3))[-5,]
expand.grid(rep(list(-1:1),2))[-5,]
```
[Answer]
# JavaScript (ES6)
Two alternate methods, both longer than hardcoding.
## 49 bytes
```
_=>[...'11202200'].map((n,i,a)=>[~-n,~-a[i+3&7]])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/e1i5aT09P3dDQyMDIyMBAPVYvN7FAQyNPJ1MnURMoWaebp1OnmxidqW2sZh4bq/k/OT@vOD8nVS8nP10jTUNT8z8A "JavaScript (Node.js) – Try It Online")
## 51 bytes
```
f=(n=1679887e3)=>n?[n%4-1,~-(n/4%4)]+' '+f(n>>4):''
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYjz9bQzNzSwsI81VjT1i7PPjpP1UTXUKdOVyNP30TVRDNWW11BXTtNI8/OzkTTSl39f3J@XnF@TqpeTn66RpqGpuZ/AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~28~~ 27 bytes
```
tail.mapM id$[0,1,-1]<$"ao"
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzvyQxM0cvN7HAVyEzRSXaQMdQR9cw1kZFKTFf6X9uYmaebUFRZl6JQtr/f8lpOYnpxf91kwsKAA "Haskell – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~18~~ 16 bytes
```
echo}.,{;~0 1 _1
```
[Try it online!](https://tio.run/##y/r/PzU5I79WT6faus5AwVAh3vD/fwA)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 41 bytes
```
(1..-1|%{$i=$_;1..-1|%{"$i,$_"}})-ne'0,0'
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X8NQT0/XsEa1WiXTViXeGsZTUsnUUYlXqq3V1M1LVTfQMVD//x8A "PowerShell – Try It Online")
Double-for loop over the range `1..-1`, with a `-n`ot`e`quals at the end to pull out the extraneous `0,0` entry. They're each individually left on the pipeline and implicit `Write-output` at program completion gives us newlines for free.
---
Sadly, just the barebones string output is two bytes shorter:
```
'1,1
1,0
1,-1
0,1
0,-1
-1,1
-1,0
-1,-1'
```
But that's boring.
[Answer]
# [Python 2](https://docs.python.org/2/), 39 bytes
```
n=6;exec'n+=~(n==2);print n/3,n%3-1;'*8
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P8/WzDq1IjVZPU/btk4jz9bWSNO6oCgzr0QhT99YJ0/VWNfQWl3L4v9/AA "Python 2 – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 27 bytes
```
tail$(,)<$>t<*>t
t=[0,1,-1]
```
[Try it online!](https://tio.run/##y0gszk7Nyfmfm5iZp2CrUFCUmVeioKIQ878kMTNHRUNH00bFrsRGy66Eq8Q22kDHUEfXMPb//3/JaTmJ6cX/dSOcAwIA "Haskell – Try It Online")
The output is `[(0,1),(0,-1),(1,0),(1,1),(1,-1),(-1,0),(-1,1),(-1,-1)]`.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 13 bytes
```
3,:(2m*{2b},`
```
[Try it online!](https://tio.run/##S85KzP3/31jHSsMoV6vaKKlWJ@H/fwA "CJam – Try It Online")
## Explanation
```
3,    e# Range [0,3):       [0 1 2]
:(    e# Decrement each:    [-1 0 1]
2m*   e# Cartesian square:  [[-1 -1] [-1 0] [-1 1] [0 -1] [0 0] [0 1] [1 -1] [1 0] [1 1]]
{     e# Filter by
 2b   e#   conversion to binary:
},    e#                    [[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]]
`     e# Stringify:         "[[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]]"
```
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), 24 bytes
```
11#v91090~9~19~<
9.._@#,
```
[Try it online!](https://tio.run/##S0pNK81LT/3/39BQuczS0MDSoM6yztCyzobLUk8v3kFZ5/9/AA "Befunge-93 – Try It Online")
I feel like this challenge is missing answers from 2D languages, even if most don't move diagonally. This outputs space separated numbers, each pair separated by tabs.
[Answer]
# [F# (Mono)](http://www.mono-project.com/), 54 bytes
```
let f=Seq.where((<>)(0,0))(Seq.allPairs[-1..1][-1..1])
```
[Try it online!](https://tio.run/##SyvWzc3Py///Pye1RCHNNji1UK88I7UoVUPDxk5Tw0DHQFNTAySYmJMTkJhZVByta6inZxgLpTT/pynU2CmAFGSWpBYpaBQUZeaVpOUpKKk6Kmn@BwA "F# (Mono) – Try It Online")
44 bytes - thanks to Laikoni:
```
let f=Seq.tail(Seq.allPairs[0;-1;1][0;-1;1])
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 8 bytes
```
Ċ{ṡᵐ≜}ᶠb
```
[Try it online!](https://tio.run/##ASEA3v9icmFjaHlsb2cy///EinvhuaHhtZDiiZx94bagYv///1o "Brachylog – Try It Online")
### Explanation
```
Ċ           Couple: take a list of two elements [A,B]
 {   }ᶠ     Find all…
    ≜         …possible values of…
  ṡᵐ          …signs of A and B
       b    Behead: remove the first one which is [0,0]
```
[Answer]
## [Perl 5](https://www.perl.org/), 31 bytes
```
map/1/&&say,<{-1,0,1},{-1,0,1}>
```
[Try it online!](https://tio.run/##K0gtyjH9/z83sUDfUF9NrTixUsemWtdQx0DHsFYHxrD7//9ffkFJZn5e8X9dX1M9A0MDAA "Perl 5 – Try It Online")
[Answer]
## [Bash](https://www.gnu.org/software/bash/), 30 bytes
```
echo "
"{-1..1},{-1..1}|grep 1
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I19BiUupWtdQT8@wVgdK16QXpRYoGP7/DwA "Bash – Try It Online")
Prints a trailing space on each line but the last. (Thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil) - this originally printed a leading space, but a trailing space is better as per their comment)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 12 bytes
```
3:qq2Z^[]5Y(
```
[Try it at MATL Online!](https://matl.io/?code=3%3Aqq2Z%5E%5B%5D5Y%28&inputs=&version=20.9.1)
My first ever serious MATL answer! Thanks a lot to [Luis Mendo](https://codegolf.stackexchange.com/users/36398/luis-mendo), [Sanchises](https://codegolf.stackexchange.com/users/32352/sanchises) and [DJMcMayhem](https://codegolf.stackexchange.com/users/31716/djmcmayhem) for the help.
### How it works
```
3:qq2Z^[]5Y( – Full program. Outputs to STDOUT.
3:           – Range 3. Push [1 2 3] to the stack.
  qq         – Decrement by 2. Yields [-1 0 1].
    2Z^      – Cartesian power of 2.
         5Y( – Replace the row at index 5 with...
       []    – An empty vector.
```
[Answer]
## Batch, 77 bytes
```
@for %%x in (-1 0 1)do @for %%y in (-1 0 1)do @if not %%x%%y==00 echo %%x %%y
```
63 bytes if a nonstandard separator is allowed:
```
@for %%x in (-1/-1 -1/0 -1/1 0/-1 0/1 1/-1 1/0 1/1)do @echo %%x
```
[Answer]
# Pyth, ~~11~~ 9 bytes
```
t^+U2_1 2
```
[Try it here](http://pyth.herokuapp.com/?code=t%5E%2BU2_1+2&debug=0)
### Explanation
```
t^+U2_1 2
  +U2_1     [0, 1, -1]
 ^      2   Product with itself.
t           Exclude the first.
```
Equivalently, we could use `t*J+U2_1J`, but that's not any shorter.
]


[Question]
      [
**Challenge:** Print the **entire** printable ASCII charset (not just a range!) in order.
```
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
**Rules:** *read closely*
* No other characters allowed in the output.
* Program/function does not accept input.
* Try not to hardcode/embed the output.
* This is code golf, shortest answer wins.

[Answer]
# Scala, 25 bytes
```
()=>' 'to'~'foreach print
```
Anonymous function with no args which prints given range
See it online: <https://ideone.com/fX2rwf>
[Answer]
## Lua - 41 bytes
```
for i=32,127 do io.write(("").char(i))end
```
[Answer]
# [2sable](https://github.com/Adriandmen/2sable), 8 bytes
```
95Ý32+çJ
```
[Try it online!](https://tio.run/##MypOTMpJ/f/f0vTwXGMj7cPLvf7/BwA "2sable – Try It Online")
Same as for 05AB1E
### Explanation
```
95Ý       Push [0..95]
   32+    Add 32 (vectorizes)
      ç   chr (vectorizes)
       J  Join by empty string
```
[Answer]
# [3var](https://esolangs.org/wiki/3var), 20 bytes
```
iiss+<+<>+<+<kkF[Pi]
```
[Try it online!](https://tio.run/##My5LLPr/PzOzuFjbRtvGDkRkZ7tFB2TG/v8PAA "3var – Try It Online")
### Explanation
```
iiss                 Increment A twice, square A twice (set a to 16)
    +                Add A to B (set R to 16)
     <               Set B to R
      +<>            Add A and B (16 + 16 = 32), store to A and B
         +<+<        Add 32 to B twice more (B = 96)
             kk      Decrement B twice (B = 94)
               F[  ] Do B times
                 Pi  Print A as character and increment A
```
[Answer]
# [Actually](https://github.com/Mego/Seriously), 12 bytes
```
:95r:32+♂┌εj
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9/K0rTIythI@9HMpkdTes5tzfr/HwA "Actually – Try It Online")
### Explanation
```
:95r          Push [0 .. 95]
    :32+      Add 32
        ♂┌    Map chr over TOS
          εj  Join by empty string
```
[Answer]
**VBA (Excel), 28 bytes**
using immediate window.
`for i=32to 126:?chr(i);:next`
[Answer]
# [Perl 5](https://www.perl.org/), 21 bytes
```
print map{chr}32..127
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvRCE3saA6OaOo1thIT8/QyPz/fwA "Perl 5 – Try It Online")
[Answer]
# [Swift 4](https://developer.apple.com/swift/), 57 bytes
```
for i in 32...126{print(UnicodeScalar(i)!,terminator:"")}
```
[Try it online!](https://tio.run/##Ky7PTCsx@f8/Lb9IIVMhM0/B2EhPT8/QyKy6oCgzr0QjNC8zOT8lNTg5MSexSCNTU1GnJLUoNzMvsSS/yEpJSbP2/38A "Swift 4 – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 2 bytes
```
Vp
```
[Run and debug it](https://staxlang.xyz/#c=Vp&i=&a=1)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
ØṖ
```
[Try it online!](https://tio.run/##y0rNyan8///wjIc7p/3/DwA "Jelly – Try It Online")
Yep, it's included, but here's an answer without the builtin:
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
95Ḷ+32Ọ
```
[Try it online!](https://tio.run/##y0rNyan8/9/S9OGObdrGRg939/z/DwA "Jelly – Try It Online")
```
95Ḷ        create lowered range, from 0 to 94 inclusive
   +32     add 32 to every element in the range
      Ọ    cast the entire list to characters and implicitly print
```
[Answer]
# [Yabasic](http://www.yabasic.de)/VBA, 29 bytes
An anonymous function that takes no input and outputs to the console.
Note that the VBA answer could be 1 byte shorter by using `Chr` instead of `Chr$`.
```
For i=32To 126:?Chr$(i);:Next
```
Yabasic: [Try it online!](https://tio.run/##q0xMSizOTP7/3y2/SCHT1tgoxF/B0MjMyt45o0hFI1PT2sovtaLk/38A "Yabasic – Try It Online")
VBA:      There is no TIO for VBA :(
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 47 bytes
```
for(i=31;++i<127;)alert(String.fromCharCode(i))
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z@Yk1pUYpucn1ecn5Oql5Of/j8tv0gj09bY0FpbO9PG0MjcWhOsRiO4pCgzL10vrSg/1zkjscgZqFsjU1Pz/38A "JavaScript (Node.js) – Try It Online")
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), ~~80~~ ~~68~~ ~~67~~ ~~62~~ 45 bytes
```
?-between(32,126,I),writef('%n',[I]),1=0;1=1.
```
[Try it online!](https://tio.run/##KyjKz8lP1y0uz/z/3143KbWkPDU1T8PYSMfQyEzHU1OnvCizJDVNQ101T10n2jNWU8fQ1sDa0NZQ7/9/AA "Prolog (SWI) – Try It Online")
[Answer]
# [Befunge-93](https://de.wikipedia.org/wiki/Befunge), 18 bytes
```
 g:"~"`#@_:,1+00p#
```
You can [try it here](http://www.quirkster.com/iano/js/befunge.html). The leading space is important!
```
                     The current character to be printed/checked, starts loop with a space
  g                  Push character from (0|0) onto stack(using the implicit 0s on the empty stack)
   :"~"`#@_          Check whether the char on (0|0) is over ~, if yes then end
           :,1+00p   Duplicate current char for output and incrementation
                  #  Since the code is a torus, it would continue at (0|0) so we skip it, since it could break the code.
```
[Answer]
# Python - 41 bytes
```
for i in range(32, 127, 1):
 print(chr(i))
```
Python has a built-in ASCII function, so we can use that and print all 95 characters in a loop, one at a time.
### No newlines - 50 bytes
```
for i in range(32, 127, 1):
 x = x + chr(i)
print(x)
```
This is *just in case* newlines aren't allowed, so this entry still gets in.
[Answer]
# [naz](https://github.com/sporeball/naz), 32 bytes
```
4a5m6m6a2x1v1x1f1a1o3x1v1l0x4d1f
```
[Try it online!](https://sporeball.dev/naz/?code=4a5m6m6a2x1v1x1f1a1o3x1v1l0x4d1f&input=&n=false)
**Explanation** (with `0x` instructions removed)
```
4a5m6m6a2x1v   # Set variable 1 equal to 126
1x1f           # Function 1
    1a1o       # Add 1 to the register, then output
        3x1v1l # Goto the start of the function if the register is less than variable 1
4d             # Integer divide by 4, setting the register to a value of 31
1f             # Call function 1
```
[Answer]
# [Pxem](https://esolangs.org/wiki/Pxem), 17 bytes (filename) + 0 bytes (content) = 17 bytes.
* Filename (some unprintables are escaped): `~.z.c\001.-.c\037.a.s.p`
* Content: empty.
[Try it online!](https://tio.run/##xVltU9u6Ev6eXyFEiO0EJ7ZJW8ARPRwKp52h0IH2zrm3SRljK8HTxPbYTshr/3rvSrIdOy/00MvMnYHYXq12n12tVivJsaKHn7Y/CNw@lRU5ojFS6dAcDqzoO9I0wzDpOPDDGF2e3Z1eXpIzU44nAUU9Gtu@161U@BcIGFieo5w0HDpqeMN@HxknFb1SSTp/Ov38nuCynPAhNUgF8CalPGOP2vFCvKgLnKr9cvXh77vbz@@IoWkHKfHT9e2Hvy//fXd2fXNzfvaZ6KZtRRTh8uzP09v3d/86v7n9cH11XJssMHI9JE8UxA3zUeBH7thkH7U/TZNGll1Ku/5nS086GPatmKLogfXzgxjeHv3QiYK@G5tW37UipPaQVJ7pNVz@Ay8kIrGnZF59ubw8@/iOHAtNKUgZcTc7w8FgYkYPbjc2s2/EeiZEaj/4qLyrIEVg0RUUhK4Xd9Fe1G57DLO2u1ttLI7Rpz5lsofw79FHGgoPqWxcrdi97zP0tN@vM7e6MdITQHRk9RHeQV2rH1E8n89eTsHCpGHoh2NZ2S60bCTsZcZf4JK6Q8@OXd9D1j2MuDyIesqMcyDMBSMdYQRULkDWFHOR9YDIiuSQxvu2MnO7sns/7HZpSAjGyqzrhzbt9ofRg6yYwENk4I5pOIdH3/UoSrgVE3pCe4toCjyGoYfgYdp9P6JJF1Bpk4Sdcds7PzACFak@jM0FBb/OouG9jFG9Wsb7GAMokxO@fkOdKuKkTOfC8ft9K9SIbSZKwTGlzLCBNblPwc/4M4ppUKsx7dnnCeGvVpz6i3@aWTvRzMXSV3l/bOfP2N3ovm9532XwbALQJuTAmM/loxaxKxW7RfQDsOPP878@XM3oIIgnBPMHFhIJ5g9ckJ9aDR7jk0oGn0SxZX/fx8dYydEid0oTWghpRGY/EaWOYg4s1@NRIJmxb0UDsgwgeFqBG1t92ctQy69ftYhXqXgtcqQpb2WvdmAox17BUnvg5Ht4YOiBApayl9fpy5vkpZk2NV@xl6NMvK4Z8NwhR6/F4zDh0zXGCJNaO8pYDcGq6wfJ803mSvAADa0@c1EQ0hH31SKjyukLi/G3Ze1YLmswPTBK6CBG2LP0RVlTlEpFyCKOH7OZknBDHH8T0cl/yxDTPGLzRBG4mfhl5x@NekPhgYT7SwDmQsxuvGe3PbxfgGHmbFvMBKIyBN351bvZr@Xy8X78TiThJ7fn@SG9c6jlQGJ6gODyaBSzuGFxXAZbsYWZ2IwMEzxNLHWLLWQ0QjDLQAqqP@6j@hj@J/sIMk59iufYtiC7nVQMbCaddlE08WJrjERaCkK/F1qDZR5MFamquQ5usUoi@syj45hB/dH49vVxPJl2yo1ZKgTm@qKsgxF9POuJNKKpR50ajAafMF9dR8wSeOl0SMXMPqAnTBvRhw0e5FiEk1RUr7PRVIRFZeYygQD0BFg4B4NDZJdk4lTddE/AAFdVU/dlANyO6dA@ZUtmjrTI@kI3nNfhpzoQgoGRo@lSjXKirYkHBlVX1nWk9CVG1VwUFHmpoo1qvAFZk8UCZdDKMDRfmd6gSsD4hR@R5mENiMCwp0MUMweBCEFpMIo3OAFf5knKbLUbisTEkNsYlr02VvwomSsI3p5voovTYM7bx@xIkuwOAU1YWUbLtEOSJpOtVmwI@AKqIHAKixKENjKzJtZhAwv4h1HTtM4UckIhGPOo7/JRZpp82U57C7wZKrYgi5Kgjet3x5DdoSakdkwddH59AZzM1nSZSmRweYlRv@4PVWnsekMKkzOHAhL8LOpBpfkMJPchtb6viHnFxai/Kad52EoHoFJJXlqvDhNoCV9emOsFwxh5fgxvMe3RkMl7SpIzSslq81BExLo8N1oVmRu4pVUCz1OwmbZRVddq8lJpfgQSizbltqhXdUbm1pCy8az0xGQvxOv2@cXybUFslM2vLcnq@VN2lAZ/YcaKfAsJtsWSRTRtGBDZtRogfyT5tJp7L9rhCrVrJBI9rgDopgCgDIC5A9VUoZmmzfnyky0cAfDW9BXu8Mkcy4hxsObw4hwI2RxwaBfKcYcVqGzOshhb7cUTK68DlWocKCtWPa7mlAL8jegeHfJbqwwIg65ZwBdxjJ@JgxjKbHxPduRVla0CwQCvbQW3iW4UQBODqR7fK2gT5slvYJ5swnzy8pgnWzBPl1XEM1BP78kaaEJeHvV0C2orRV0kx0/OogdqBeQF6qFBTguTuUP4Vi2XHeWl4g5hLE@kRgcy7rvrz@8@np7dXL8/vzk3Syt1Ni@JtbUyWM9LqW23nI3XqqNrL@EH9Xk61Y114ipXixV3KzReOj4f387z8FVfwiflp3WO9LVJYo6M306fI70KvfOLQPkYTWnoq447ciPYkK8tAKCRjIyTkf6WLQMjozHSlWP@qjdGxupqsPd/NmfvuebsLc3ZK5iTbIvTebWT279e@bB/DUMaBb7nuF4PwYaWrZ8vso@FnTY/kJRyx1GuByXAPkIsMyRpiWcQM7/Xk5Yne@zwT@eHf3juO0g99ZA6iof6PA6RehYhTTcOmq9evzk8QtLXtlftSPNeSANUn8MWH1hhSxGT5msQww95MCfjsrxywMhPBPA8gvJBahRSUsNulxDKKjhxtmNiScGJcWAlq4L4oVTMzgzS0@EENj@Irda/di86VQVxVh0Vj3dXWel5wkrXWFl/9kMFswYpQ@TIDXzrZ8DQYDzXj9wnUaNebeT3bNtODBrSXF4Z9LRGnEkALs68pqwBTm1KTcpO22PUaqkSq/EfnFBanm4mFeX@k8G0LIsFFTqIBMxL47VaWDTzOjm/bpUS7aX/yZcvGJP5yiVvHt@7M9Pa@W12YlXKouqdTmFPkDIv28HohLjhZIa3LPhv2pop59R0mpjLebIV6D9DWIS26bRoDYkYtG4cSiIlacrPXZZ4HBrWUTCmA7vOL3fcaFAv7YInIQSTlnGhJX6gE2SFFHVDf8DbC80D33G7brLz@PzhmtHg7yGOg@i40ei58cPwvm77g8Zf79XPgUUvrMcp9RoFQaVd6FKgsD3z2ZlWL5Uurk4/npNlhEg/6tO63dY0va6y58GbulWP6gE4u3R7/eXm7JxI0s98pHIJeP5oI9XmSbwQx6LP1mbeeRNTSU4COrk/YBDFFZQsw396X3d689fdx9O/@f0ems8RZzE02LerR0jhl1UgQ1yREMwGCKme/uuphVaylEpZovqGqo2GlHygahk@uPz05J@B/MpM4BePQ0aGQe1UKkAM14gzlMKInSZSr5pMVJ5JIHNyyKAuYvdichBBRx8FEJ40dgd0P7CD4f4ompqOFVMlb1/z16kjttw@uAU1DZERdLddUg29@aZ5ePC6eVhiGbot19uzw/airZQbbR1ScTI8FtGQNLNq2SG5WM4sdha@AO@La1Z2n5uFyjIqoD0dM0ks9Abq@zBGXUBEHUmZo1IxvQ2scZ96/yAY5vPNoSDmKMFpuHOimJ6kLbEPAALzmmBJVCQoOcu/vrlldwKXFyQ9JMVtD@omZwhfvTt/GAfDmB2iN77xkC03@LlhoZXoSnKrxRWiy4u17qKsanzj7lgX8cv@4tT8IF9SiezYhOxIri5EXhRSri9uUdnNsyaHvZcXayVZF2Ge6PaG7MoElY3krtRgYNW34uBf2LxTRJwoE45fwaunVzEIt9t7Pt7PzvtnyRXNY9w9ZsuWx9ryqLj6g4OsBN3uJgjFefSA1OjnfwE "Dash – Try It Online")
## With comments
```
XX.z
.a~.zXX.z # push 127; while size<2 || (pop!=pop); do
  .a.cXX.z # dup
  .a\001.-XX.z # push 1; push abs(pop-pop) iff size>=2
  .a.cXX.z # dup
.a\037.aXX.z # push 31; done
.a.s.pXX.z # pop (* to remove 31 *); while size>0; do printf "%c", pop; done
.a
```
[Answer]
# [Factor](https://factorcode.org/), 18 bytes
```
32 126 [a,b] write
```
Works in any modern version of Factor that supports printing non-string sequences directly. (i.e. not TIO.)
[Answer]
# [Kotlin](https://kotlinlang.org/), 27 bytes
```
(' '..'~').joinToString("")
```
[Try it online!](https://tio.run/##y84vycnM@59WmqeQm5iZp6GpUF1QlJlXkpOn8V9DXUFdT0@9Tl1TLys/My8kP7gEKJWuoaSk@V@z9j8A "Kotlin – Try It Online")
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), 23 bytes
```
;=a 31W>127=a+1aO+Aa"\"
```
[Try it online!](https://tio.run/##lVhpc9u2Fv3eX0GzqUWINC25nXYimfYkrvMm8xo5L3abaSUlAkFIYkMRChfbqcT@9b57wQ3U5jQfMiJwcDecu8B/0nsas8hfJieh8Pg/LKBxrP039Gfz5DqKRKTxx4SHXqzJr1WWA97SKObNfeVMiXqXhom/eBp3m0ScLlZMhHESpSwRkUHJKpn7sR2LNGLcoRns@Mv3cz/h8ZIybhT7C5qwuXH6wRiOxqPhKIb1rDc2198OP4zCcdsYhetnhLRPSbbk/BPsRjxJo1BThA874/U6TIMgy4W5FnM6ZBXwRKOOa/NHzgwFTvqFCDziOA69xB89FeIov@04dcF2g4IaO@DhLJkTiw7ZmGSJAMf9cLbTqiyT4dDufn97fesMx/08VL/RIOWrOKGJz7Ql3oLhkpVrb4WnP4Uo3tMIfOj06bkUU@jvU9PM/WOOXB/SsV3K6vtTg5HCHpYpvmZRGsqwR@JBC/lDzojM424627G@xzspxK43ATdIFy6P9uDKTcC9FCLgNNwDrHazglW/QDAiGlTEy0O3QbI4XaJ0S4r66NGEAtdyRxUlO5wpvutzuzwpvpugLTfKBRXGPwdoXoGgmg9W05BxMc29Vtw4PlaMBz7mv8oooPAqBEVItvhTcr3OprtXYzJ8cfLHuH1qdSvK0@NjvGCUaeh3OmojmZculpUzk9KZZzI/MzLJgmReu3JU23p8TBvXNlNxmoo7agKznMzLNJ4buEr6eapcD357/e5m8OZ6cOessiJhXns8TDY48JT7Q3ry18cx/t85ef4RQrAZACkUjM0OsclHELCpGR951J/6gMtDlOMwUGCuPwtRjuLJsMaMK2rmBu9BYQbfC9/TOkd4P6Xl/TpB1bpsTH4NP4XiIdT8yjKt1TCtNWnGXLpAyvgq0f1aeo08czukENAiXSjZJFWxUXOKep7ClfJ8zRmTKqWDZFCDD8JPmvBFGhyEt5twz79Xvay38CYal1CKekOTuQ28CZki9RT83ndJ@hUNQ5FooAruRHO/aH/xSOhgqvD@pe5a4Xf0SX0gPg2Eom8pHg7rq8Wv10cGPe@Qr3K@3f4K7/njUoRIUppwaZCWCKiNIZ8B3@65BsbxCIwM9lSSc/Xe9tabiwaqQfya9gNoiId5r1TviviDoqSSnPMopFFCygqC7XYjB3QEG0Q/1BmkvML5J0LJxALM5PKIrVfB@Jen1ODgWhkdaI5PBgcp5DpU6Tl6a0xgjotHt@P2JRl1T60zSSuMBjDLVYkEGnBYyYcYaufDHYL1FrYltl639Bb@ILVL9dCKRQ@sWvghMMnTPqcCCMVDJlJc5l5Pe7ai2WRXS5f2N/PI6nbIet3ZqFnFgHCoZqETkwJQKNwuPQiqddkRX3IKvUetQE8wvhq1DjK@QqmXCotFd4VT1Lv9ErIezZyIf079iBv6NNaJtcIRWW65yhab@4H3cRkJxmNEvfp1cHX3@mZwW/fmV1ADDrVmhSX5BcNkXokZukqnkzetzKp9hVeXPZl15tompzljOM7TOB/jhwfzsXfOytnYK2fjqSMtsktTUNnRdA@d3vjQu8OZRqNZusCB49nKM7uZBkq0KXoJHdXFRtrneWCnJFPuGANhMMu1@MZIAUtsY6xAcQ7Nf4d0wR03/w2qY4dtz67ygGHbdoWqKktexXXUnvgiNHSzklqFx9XKkVMepaajW5puunYuo@ripr5Vm27cPzlLbD@W/LVgXMqmhSot4jM/Trh0kawgtF3sVeUDaeMtYegDMElbpDDkuZCoj5QlwRcNeoHG5jSCL5hZAhHOoCb1a4LQseMqGiEwVedSr7ZIMniBGq6SB0StPfUYlb83@jtpoA@Edo@SoVCmgYe2ShXeEdRKJasw4MSqQqC/1S2DOBfFk0zXLdd5mU6nPLJpEAhmwADuCQwSNTrAiA5M5BZQ3oUnJXHB8E99ZoKrD5Bx3OhCF5Y78iVnY2699yHx9VGoE8IcZseBDy/EjqWd1JN9WWkYyVTL3uWWNVr3NBDg6w9nz394/uNPZ89/bMvViIaeWGDY1PPXukWdCwwZbYS2hrRetBBSJXoe3sIqV@1uYMBlaWYuyZ5GYnEFDLgSHgyaxduJ9Epz1eu0WYF7keDMphr5UhpJ1aWrfKl4XMr/1e2J3K76UNO5PY7q/5OHioJo80d/s4or2KNKgXxrNR9ADeQvFRI9Vg0pk0lF/4zcuqjGt0awS8vixBNpYj9E0LhBYJ7nxKKNmN00BdVaC2n6aCSfhwXZgGmXe@SXbAQI6e3ETLA3fjMhVjUzqZaYQFEsIvV1YaMtfGs4f7KFxHfBLmR7C4l9eRfydAspXwM7kN9tyxS77fywhZRT9w7keYWsqFIewYmgOqKeudh/ZrbvzOX@M1jyd545rs4YtMzrxt9pLotjvUbmrZ88Rnvudkb2lWP5rrUrYI4Ca9QWfNKu16BSed43E5naxfvcdSr9bkP4@0r4Crtnv5G0fbKRbjvJ/DoXAU3fuaA7g8W2ff@PckgGrbbbchuPNAvLv/JZVjBa/pUShazXut6M2m2hwJMqykNPqPIcb1tzBS5bPY71l9SEqbI0ATocMZlZm2R62IvrhvF3S614zac74CA6ZRWBieV@eAad8B/413eo9n33/UX37CeHml16Y76g@kj/Pw)
Unminified:
```
; = a 31
: WHILE (> 127 (= a (+ 1 a)))
    : OUTPUT (+ (ASCII a) "\")
```
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 7 bytes
```
' '~R&o
```
[Try it online!](https://tio.run/##y6n8/19dQb0uSC3//38A "Ly – Try It Online")
```
' '~     - push first (" ") and last ("~") printable characters
    R    - generate a rage of codepoints
     &o  - print the stack as characters
```
[Answer]
# [Z80Golf](https://github.com/lynn/z80golf), 9 bytes
```
00000000: 3e 20 06 5f ff 3c 10 fc 76                     > ._.<..v
```
[Try it online!](https://tio.run/##q7IwSM/PSfv/3wAKrBSMUxWMDBQMzBRM0xTS0hSMkxUMDRTSkhXMzRSwATsFvXg9Gz29sv//AQ "Z80Golf – Try It Online")
Assembler source (z80asm):
```
start:
    ; start at space
    ld      a, ' '
    ; loop counter
    ; I could also cp 0x7f; jr nz, .loop but this is faster to TOTALLY make up for below
    ld      b, 0x7F - ' '
.loop:
    ; Call 0x38, then nop slide to 0x8000 to print A to stdout
    ; only has a 130842 cycle overhead, which is worth the 2 bytes it saves
    rst     0x38
    ; set A to the next char
    inc     a
    ; Decrement b, then loop if non-zero
    djnz    .loop
    ; Exit
    halt
```
Pretty straightforward loop approach.
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang) (v2), 23 bytes
```
;;=s@W>95s=s+sA+32sO^sN
```
[Try it online!](https://knight-lang.netlify.app/#WyI7Oz1zQFc+OTVzPXMrc0ErMzJzT15zTiIsIiIsIjIuMCJd)
Another Alternative is
```
;=a@W>95=a+1aO+A+31a"\"
```
[Answer]
# Pascal, 66 B
This program *requires* to be run on a processor using the ASCII character set (or a binary-compatible superset).
The output will look quite different for instance on an IBM mainframe using EBCDIC.
```
program p(output);var c:char;begin for c:=' 'to'~'do write(c)end.
```
Note, in Pascal `for`-loop limits are *inclusive*.
During the final iteration `c` assumes the specified value `'~'`.
[Answer]
# [Alice](https://github.com/m-ender/alice), 14 bytes
```
' w.oh.'~h-$K@
```
[Try it online!](https://tio.run/##S8zJTE79/19doVwvP0NPvS5DV8Xb4f9/AA "Alice – Try It Online")
## Explanation
```
' w.oh.'~h-$K@   Full program
'                Adds 32 (space) on the stack
  w        $K@   Repeat until...
      .'~h-      ...we reach 126 (~)
   .oh           Print and increase the current character
```
[Answer]
# [Go](https://go.dev), 45 bytes
```
func(){for i:=32;i<127;i++{print(string(i))}}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70oPX_BloLE5OzE9FSF3MTMPK6yxCKFNAXbpaUlaboWN3XTSvOSNTSr0_KLFDKtbI2NrDNtDI3MrTO1tasLijLzSjSKS4BUukampmZtLVRTF0gT2DQNTYVqrjQNTS6w2pw8JJaSgmKMkrKKqpq6hqaWto6unr6BoZGxiamZuYWllbWNrZ29g6OTs4urm7uHp5e3j6-ff0BgUHBIaFh4RGRUdExMbFx8QmJSckpqWnpGZlZ2Tm5efkFhUXFJaVl5RWVVdU1tnZImF9RFCxZAaAA)
Prints to STDERR.
[Answer]
# [International Phonetic Esoteric Language](https://esolangs.org/wiki/International_Phonetic_Esoteric_Language), 21 bytes
```
{3j}{w}ɑeχue1søɒ
```
## Ungolfed
```
{3j}{w}   ( loop bounds: 32 w <= e < 127 3j )
ɑ         ( loop )
 e        ( push index )
  χ       ( ord index )
   u      ( pop-output without newline )
    e1sø  ( increment index )
        ɒ ( end loop )
```
]


[Question]
      [
## Introduction:
In the **northern hemisphere** (i.e. Europe, North America, etc.), the seasons are divided like this:
- **Spring:** March, April, May
- **Summer:** June, July, August
- **Autumn:** September, October, November
- **Winter:** December, January, February
In the **southern hemisphere** however (i.e. Australia, South America, etc.), the seasons are divided like this:
- **Spring:** September, October, November
- **Summer:** December, January, February
- **Autumn:** March, April, May
- **Winter:** June, July, August
This difference is due to the position of the sun regarding the equator, where the northern and southern hemispheres have opposite seasons.
## Input:
In this challenge, we'll take two inputs:
* One for the month (`1 <= m <= 12` or `0 <= m <= 11`) (examples and test cases are all 1-indexed).
* And one for the five 'position-groups' at the latitudes of Earth (`-2 <= p <= 2`), where `-2` is the Antarctic, `-1` is the southern hemisphere excluding the Antarctic, `0` are the Tropics in proximity of the equator, `1` is the northern hemisphere excluding the Arctic, and `2` is the Arctic.
Although the Arctic, Antarctic and Tropics of course still have seasons, for the sake of this challenge we'll say the Arctic and Antarctic are in a constant state of `Winter`, and the Tropics are in a constant state of `Summer`.
Here a visual representation of these five groups, where `-2` is the Antarctic Circle; `-1` between the Tropic of Capricorn and Antarctic Circle; `0` between the Tropic of Capricorn and Tropic of Cancer; `1` between the Arctic Circle and Tropic of Cancer; and `-2` the Arctic Circle.
[![enter image description here](https://i.stack.imgur.com/BB40hm.jpg)](https://i.stack.imgur.com/BB40hm.jpg)[![enter image description here](https://i.stack.imgur.com/WzAmNm.jpg)](https://i.stack.imgur.com/WzAmNm.jpg)
[Source: COSMOS - The SAO Encyclopedia of Astronomy](http://astronomy.swin.edu.au/cosmos/)
## Output:
One of `Spring`, `Summer`, `Autumn`, or `Winter`, following these rules:
* Is the position input `2` or `-2` (Arctic or Antarctic), always output `Winter`.
* Is the position input `0` (Tropics), always output `Summer`.
* Is the position input `1` (northern hemisphere), output one of the four seasons based on the month input: `Spring` (`m = [3,5]`); `Summer` (`m = [6,8]`); `Autumn` (`m = [9,11]`); `Winter` (`m = 12 or m = [1,2]`).
* Is the position input `-1` (southern hemisphere), output one of the four seasons based on the month input: `Spring` (`m = [9,11]`); `Summer` (`m = 12 or m = [1,2]`); `Autumn` (`m = [3,5]`); `Winter` (`m = [6,8]`).
## Challenge rules:
* Output any four distinct values of your choice indicating `Spring`, `Summer`, `Autumn`, or `Winter` (please state what you've used in your answer).
**-15 bytes bonus** if you output `Spring`, `Summer`, `Autumn`, or `Winter` as text (case-insensitive, so can be fully lowercase or fully uppercase as well, instead of the used title-case).
* Month input can be in any reasonable format. Can be either a 0-indexed or 1-indexed integer, Date-object, Month-String, etc.
* Position input will always be one of these possible five inputs `-2`, `-1`, `0`, `1`, `2`.
## General rules:
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
* [Standard rules apply](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
* [Default Loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* If possible, please add a link with a test for your code.
* Also, please add an explanation if necessary.
## Test cases:
```
Position    1-indexed Month    Output
-2          8  (August)        Winter
-2          12 (December)      Winter
-1          3  (March)         Autumn
-1          5  (May)           Autumn
-1          8  (August)        Winter
-1          12 (December)      Summer
0           1  (January)       Summer
0           7  (July)          Summer
1           1  (January)       Winter
1           4  (April)         Spring
1           7  (July)          Summer
1           12 (December)      Winter
2           2  (February)      Winter
2           9  (September)     Winter
```

[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~33 27~~ 25 bytes
```
->m,l{[6,m,0,m+6][l]/3%4}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5XJ6c62kwnV8dAJ1fbLDY6J1bfWNWk9r@GrpGenpGmXm5iQXVNRY2GoZ6eIYxbWVOgEB1doVMZq6OQFl2pUxEbW1v7HwA "Ruby – Try It Online")
Return values are:
0 -> winter
1 -> spring
2 -> summer
3 -> autumn
[Answer]
# [Python 2](https://docs.python.org/2/), 29 bytes
```
lambda p,m:[0,m+6,6,m][p]/3%4
```
[Try it online!](https://tio.run/##hc5BDoIwEIXhtZxiNqY0DrEdDCEkngRYYLTaxJaGsPH0FUvE2bn@58ub8Jofo6dozl18Du5yHSCga1qF7lBhha5vQ38s96cYJutnEAVBDd0sEMDkBWEts1/RtKZUNG1JbWZJihm1kRQYIU74DHGyrmRmnMCC9TAN/n7LNepSNtnu@5gWaFF8zPKYRiv/AH6fzuMb "Python 2 – Try It Online")
A port of [G B's Ruby approach](https://codegolf.stackexchange.com/a/164757/76162), which turned out to be a few bytes shorter than my own:
### 32 bytes
```
lambda p,m:(p%2*(p+m/3+5)or p)%4
```
[Try it online!](https://tio.run/##hc5BDsIgEIXhtT3FbBrATiNMNWmaeJNuMIqSCCWkG0@PtY3IzvU/X@aF1/yYPCVzHtNTu8tVQ0A38FDTnofGHbrmJKYIQdTHFKL1M7CWoIdxZghgeEvYi@pXFG1pLYpyktksSRZGZrKGglBJyjdUku1LZZaRFqyHqP39xhWqTgzV7jtMMbTIPmYZptCKP6C8X8/TGw "Python 2 – Try It Online")
An anonymous function that returns the seasons as the numbers 0 to 3, where they represent Summer, Autumn, Winter and Spring in that order.
As for printing the actual season names:
### 63 - 15 = 48 bytes
```
lambda p,m:"SAWSuuipmtnrmutiemenrnrg"[(p%2*(p+m/3+5)or p)%4::4]
```
[Try it online!](https://tio.run/##hc6xDoIwFIXhWZ7ihoS0lRJpwYQ0cfAZGBzUASNgE1uapgw@fUWI2M35v1/uMS/3GDT33eHin4263RswVIm4Pp7qcZRGOW3V6GSrWm217eMzNgnfYpOqXZHuyWDBkKQUorx6Y6V2gDIOFVwcogAdzjitSPQrjC9pLoyvKV/NlPLA5CuZQ0B4SMI3PCTLl6ibhkqQGmyj@xYzygoios13GENUUvQx0zBGJfkDwvv53L8B "Python 2 – Try It Online")
There's the combined string if anyone wants it.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 78 75 (-15 bonus) = 60 bytes
Using 1-based months.
*Edit:* Rearranged mathematical operators and reduced.
```
f(m,a){puts("Summer\0Autumn\0Winter\0Spring"+7*(a*a&1?(++a+m/3)%4:2*!!a));}
```
[Try it online!](https://tio.run/##VYxLDoIwAET3nKJgNP2AApoYP8F4BhYuhEUtvya0EGjZEM5ey8q4e29mMiyoGTMbLlmrixLcR1Xwbt8kzl/U8o/NTAWFT9HcazVCL9VClEMWPrXSQmbhi0u1etoPXNYeOWNIMd1FD0gIJeJwRNvTNcauSxG6LcaugaBcwhXoUDOfNXQAGFueEJgdAHgF1yKJEbCkOr7q9I5y5P8szu2dsxhzMUH0BQ "C (gcc) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 26 - 15 = 11 bytes
Uses the approach found by [G B](https://codegolf.stackexchange.com/a/164757/47066)
```
6¹¾¹6+)sè3÷4%“–„Ž¹Ž€È±“#sè
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f7NDOQ/sO7TTT1iw@vML48HYT1UcNcx41TH7UMO/o3kM7j@591LTmcMehjUBRZaCK//9NuHQNAQ "05AB1E – Try It Online")
or as a [Test suite](https://tio.run/##AVQAq/8wNWFiMWX/Migyxbh2MTJGTj5V/zZYwr5YNispecOoM8O3NCXigJzigJPigJ7FvcK5xb3igqzDiMKx4oCcI3PDqP9YeSLDvywgw78gLT4gw78iLP8)
]