[Question]
  [
Consider a square of [printable ASCII](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) characters (code points 0x20 to 0x7E) for side length **N**, like the following (here, **N = 6**):
```
=\    
 g \  
7     
m+y "g
  L ~ 
e> PHq
```
We also require **each row** and **each column** to contain at least **1 space** and **1 non-space** character. (The above example satisfies this.)
We define the **negative** of such a square, to be a square of the same size, where each space is replaced with a non-space and vice versa. E.g., the following would be a valid negative of the above example:
```
  1234
a b cd  
 ZYXWV
   !  
{} [ ] 
  ?   
```
The choice of non-space characters is irrelevant (as long as they are from the printable ASCII range).
## The Challenge
You're to write a program, with square source code with side length **N > 1**, which prints a negative of itself to STDOUT. Trailing spaces *have* to be printed. You may or may not print a single trailing newline.
The usual quine rules also apply, so you must not read your own source code, directly or indirectly. Likewise, you must not assume a REPL environment, which automatically prints the value of each entered expression.
The winner is the program with the lowest side length **N**. In the event of a tie, the submission with the fewest non-space characters in the source code wins. If there's still a tie, the earliest answer wins.
  
[Answer]
# Perl, 7×7 (42 non-spaces)
```
for$i( 
1..56 )
{$_= $i
%8? $i%
7? $":7
: $/;1;
 print}
```
## Output:
```
      7
     7 
    7  
   7   
  7    
 7     
7      
```
[Answer]
# CJam, 4X4 (~~12~~ 10 non-spaces)
```
 6, 
SS +
* 4/
 N* 
```
Output:
```
0  1
  2 
 3  
4  5
```
---
Previous version with 12 non-spaces:
```
 4a4
* 4S
** 4
/N* 
```
And the output is
```
4   
 4  
  4 
   4
```
As pointed out by Martin, this version has
* **4** Spaces,
* **4** `*`,
* **4** `4`,
* **4** other characters, and
* **4** `4` as the output
;)
[Try it online here](http://cjam.aditsu.net/)
[Answer]
# Marbelous - 16x16
```
....@0..@1....  
@3..0A08..@2  ..
/\--....>1  ..Hp
..@2..\\  =0@3..
ss..//  --\\\\..
@0/\  @1/\Hp..!!
:s  #the-cake-is
  2020#a-pie/lie
```
[Test it here!](https://codegolf.stackexchange.com/a/40808/29611) Spaces as blanks, cylindrical board, and include libraries all must be checked.
### Output
```
              07
            06  
          05    
        04      
      03        
    02          
  01            
01              
```
### Explanation
There are two boards here: the main board (shown below), and the `ss` board, which takes no inputs and outputs two spaces (0x20) to STDOUT.
A blank cell is equivalent to a `..`, and anything after a `#` is a comment.
![Picture of Board](https://i.stack.imgur.com/iIv75.png)
Every tick, `ss` outputs two spaces to STDOUT.
The green path is a simple loop that outputs a newline (0x0A) at the end of every 7th tick.
The blue path will output the numbers (`Hp` prints a marble as two hex digits) present in the output, at the end of every 6th tick.
After we have printed `01` once, the loop ends, and moves down the red path, which duplicates this marble.
One duplicate is printed (the second `01`), and the other is sent down the black path, which terminates the board at the `!!` cell. Because of the location of the `Hp` used in this last print, the `01` appears *before* the same tick's two spaces, rather than after, the behavior of every other `Hp` call.
[Answer]
# Python - 11x11
```
import re
[print(
    re.sub(
"0",   " ",
bin(x)[
2:].zfill(
11)))for x
in[19,15,
1920,116,
15,1,5,3,
3,3, 67]]
```
## Output
```
      1  11
       1111
1111       
    111 1  
       1111
          1
        1 1
         11
         11
         11
    1    11
```
It's a pretty messy and boring solution, but I just thought I'd show that...
1. It can be done in Python
2. If you can compress information about your code shorter than your code, then you can pull off something like this :)
This solution takes advantage of the fact that, if you're within a pair of brackets in Python, then you can split your code over several lines and arbitrarily add spaces without getting an `IndentationError`. Another way of doing something like this is by ending the line with a backslash.
[Answer]
# Python - 7x7 (37 non-spaces)
```
print( 
'%+7s' 
'\n'%1 
*6+'%' 
'-7s'% 
111111 
      )
```
## Output
```
      1
      1
      1
      1
      1
      1
111111 
```
Uses Python's old `%` string formatting operator to do the job: `+7` and `-7` take care of right/left justification, and the last space to match the closing parenthesis for `print` in particular. In preparing the format string, we also have
* automatic concatenation of string literals across lines, and
* string repetition by multiplication (giving us multiple replacement fields for the price of one)
[Answer]
# CJam, 4 x 4 (8 non-spaces)
```
 L _
{ _ 
 _ }
_ p 
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=%20L%20_%0A%7B%20_%20%0A%20_%20%7D%0A_%20p%20).
### Output
```
{ _ 
 _ }
{ _ 
 _ }
```
### How it works
* `L` pushes an empty array and `_` pushes a copy of it.
* The block
```
{ _ 
 _ }
```
pushes that block on the stack.
* `_` pushes a copy of the code block and `p` prints it, followed by a linefeed.
* Finally, the interpreter prints all remaining items on the stack: two empty arrays that do not affect the output, and the original code block.
## Alternate version
```
 L ~
{ _ 
 p }
_ ~ 
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=%20L%20~%0A%7B%20_%20%0A%20p%20%7D%0A_%20~%20).
### Output
```
{ _ 
 p }
{ _ 
 p }
```
### How it works
* `L` pushes an empty array and `~` dumps it. The stack is empty again.
* The block
```
{ _ 
 p }
```
pushes that block on the stack.
* `_` pushes a copy of the block and `~` executes the copy.
The `_` inside the copy of the block will push a copy of the original block, which `p` will print, followed by a linefeed.
* Finally, the interpreter prints the remaining item on the stack: the original code block.
[Answer]
# JavaScript (9x9)
```
 i=9;q=""
; for(;++
i< 91;){;
var q=q+(
!(i% 10.0
)?1:" ");
;i%9|| (q
+="\n") }
alert(q) 
```
# Output
```
1        
 1       
  1      
   1     
    1    
     1   
      1  
       1 
        1
```
# Notes
I made and golfed (to the best of my ability) code for a square with diagonal of any size n: 
```
q="";for(i=***n***;++i<***n^2+n+1***;i%***n***||(q+="\n"))q+=i%***n+1***?"0":1
```
replacing the \*\*\*asdf\*\*\* numbers with constants depending on the side length n, for example for n=6:
```
q="";for(i=6;++i<43;i%6||(q+="\n"))q+=i%7?" ":1
```
But, even though that code is length 46, I couldn't get the constant space to line up with a space in the diagonal of the code until it was as big as a 9x9, with a wasted line (the 5th one)
Edit: Changed to add alert(). Before:
```
 i=9;q=""
; while((
++ i)<91)
{q= q+""+
""+( "")+
(!((i %10
))?1:" ")
;i%9||( q
+="\n")} 
```
[Answer]
# CJam, 5x5, 12 non-spaces
Not a winner, but I wanted to add a rather small and *sparse* submission, since most answers just print a diagonal.
```
 1 ]
D * S
 * 5
/ N *
 1 ; 
```
prints
```
1 1 1
 1 1 
1 1 1
 1 1 
1 1 1
```
[Test it here.](http://cjam.aditsu.net/)
The last two characters of the code, don't do anything, so it actually only has 10 bytes of real code. For a smaller grid, I could even reduce it by another two bytes to 8, but that doesn't fit on 3x3, and this code doesn't work for even grid sizes.
How it works:
```
1]           "Push [1].";
  D*         "Repeat 13 times.";
    S*       "Riffle with spaces.";
      5/     "Split into runs of five elements.";
        N*   "Join those with line breaks.";
          1; "Push and pop a 1. No-op.";
```
[Answer]
# [Befunge](http://esolangs.org/wiki/Befunge), 9x9
I have no idea why I did this. It took *way* too long. I have a massive headache now.
```
8>v_20gv 
v9<^v#<4 
1@,/<>^6 
v1,*$:<p 
->,!-^87 
:^*25<^g 
_88g,^^4 
9vp\v#6< 
        @
```
Output:
```
        @
        @
        @
        @
        @
        @
        @
        @
$$$$$$$$ 
```
## Some explanation
The code uses `g` to read the `@` characters from the grid "on the fly" (and also the final space, which is `@ / 2`), and `p` to modify the loop to write the last output line.
Every single character on the code is used at some point, either as code or as data (the `9` and the `@` on the two last lines).
I basically had to do a lot of workarounds to make the code work. The instruction pointer does multiple intersections during execution, of which some are jumped over. (I couldn't use any instruction there for different directions as they would interfere. There is no NOP.) Elsewhere I either reused the same character or just undid it (see the `$:` in the middle).
I also did some creative work on the stack:
* When the (inner) character writing loop terminates (all spaces done for this line), the stack has `n,0`. I then have to decrement `n`. The obvious solution would be `$1-`, but I managed to shorten it by using `!-`.
* When the (outer) line writing loop terminates (all normal lines printed), the stack has a `0`. I then organized code changer (`20g46p7g46\p`) to use that `0`, instead of wasting 2 characters on `$0`.
[Answer]
## Python 3, 8x8
There are 50 non-space characters and 14 spaces. The last line has one useless character, but everything else is necessary.
```
(*_,q,n 
)=p=''' 
       p
'''[2:] 
print(p 
*2+q*7, 
n+p*4+p 
[0:-1]) 
```
Output:
```
       p
       p
ppppppp 
       p
       p
       p
       p
       p
```
[Answer]
# Ruby, 8x8
```
 (0...8)
. map(){
|x |$><<
32. chr*
x+[x ]*'
'<<32 .\
chr*(7 -
x)+?\n} 
```
Output:
```
0       
 1      
  2     
   3    
    4   
     5  
      6 
       7
```
[Answer]
# CJam, 5X5
```
SSSS 
1N]4 
*B11 
    S
```
And the output is
```
    1
    1
    1
    1
1111 
```
~~I was this close to 4X4 solution. `<sigh>`~~ See my [other answer](https://codegolf.stackexchange.com/a/42032/31414)
[Try it online here](http://cjam.aditsu.net/)
[Answer]
# C++, 12x12
**Edit:** So, I became a little obsessed with this challenge and managed to get it down from 17x17 to 12x12. It took me a little while to realize I could use `/**/` as a token delimiter. This code takes advantage of the fact that a line splice still works in Clang with a space after it, though it does give warnings and ruins Xcode's colorization of the code.
```
#include<c\ 
stdio>/***/ 
int/**/mai\ 
n(){for(in\ 
t/**/i=0;i\ 
<12;++i)pr\ 
intf(i^8?"\ 
           \
|\n":"~~~~\ 
~~~~~~~\x2\ 
0\n");}/**/ 
```
Output:
```
           |
           |
           |
           |
           |
           |
           |
           |
~~~~~~~~~~~ 
           |
           |
           |
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 3x3 (6 non-space [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage))
```
 3Ð
Λ q
°° 
```
**Output:**
```
3  
 3 
  3
```
[Try it online.](https://tio.run/##MzBNTDJM/f9fwfjwBK5zsxUKuQ5tOLRB4f9/AA)
**Explanation:**
```
3Ð       # Push three 3s to the stack
  Λ      # Canvas with parameters num; filler; pattern
         #  num: The amount of characters to display (3)
         #  filler: The character to display ('3')
         #  pattern: The available options are single-digit integers in the range [0,7]
         #           indicating the direction to print in.
         #           (Option 3 is a top-left to bottom-right diagonal line)
    q    # Exit the program
°°       # no-ops to complete the pattern
```
[Answer]
# [Befunge-98](https://github.com/catseye/Funge-98/blob/master/doc/funge98.markdown "Funge-98 Spec"), 8x8 (56 non-spaces [11 nops])
Note: In the interest of good sports-person-ship, this reads its own source via `'`, making it a cheat-quine to some. Read the debate [here](http://meta.codegolf.stackexchange.com/a/4878/36773).
## Program
```
 07'?>:8v
v y+da:%<
<v ':vj!-
,+# '<zzv
v1#a vj!<
>z,\1 -\v
z>+,$v z<
1_@#:<v -
zzzzzv<z 
```
## Output
```
(       
 ,      
  &     
   %    
    $   
     #  
      " 
       !
```
## Explanation
The un-golfed version
```
07'?>:8%:ad+y-!jv>'n,$v
  !jv   a,\1-\v > 's,  
    >         >       v
    v-1_@#:           <
```
(non-space and space are replaced with 'n and 's for readability sake.)
This solution is based off of the fact that using an index [0,width^2) mod the width of the square can tell you if you are at the end of the row or on the diagonal. Since all spaces are placed along the diagonal, it is easy to tell when to print a non-space!
### In Pseudocode
```
const int WIDTH = 8
push 0    //Because of the way the 'y' instruction works when picking
int row=7 //8-1 rows
int i=63  //Starting at the end allows for the cheaper i != 0
do
{
    pick variable row from the stack bottom + 1//ad+y
    if(i%WIDTH == row)
    {
        print non-space
    }
    else
    {
        print space
        if(i%WIDTH == 0)
        {
            print new-line
            --row
        }
    }
  --i
}
while(i != 0);
```
## Discussion
I'm very proud of it, though I wish I could have made every non-space also a non-nop. I'm also proud that I didn't use the standard Befunge get-increment-put trope! It prints out different symbols for non-space because I had the room for it and didn't want to be boring.
Try it on Windows with [BefungeSharp](https://github.com/tngreene/Befungesharp "Download the latest release!")!
[Answer]
# CJam, 4 x 4 (8 non-spaces)
```
 N a
` S 
 * N
X $ 
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=%20N%20a%0A%60%20S%20%0A%20*%20N%0AX%20%24%20).
### Output
```
[ " 
 " ]
[ " 
 " ]
```
### How it works
* `N` pushes a linefeed as a singleton string. `a` wraps that string in an array.
* ``` inspects the result, i.e., it pushes a string representation of the array.
This is the result:
```
["
"]
```
* `S*` joins the resulting string (array of characters), separating its elements using spaces. In other words, it puts a space character between all pairs of adjacent characters of the string.
This is the result:
```
[ " 
 " ]
```
* `N` pushes another linefeed.
* `X$` copies the stack item at index 1 (counting from the top), i.e., the multi-line string.
* Finally, the interpreter prints all items on the stack: the original multi-line string, the linefeed and the copy of the multi-line string.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 2x2 (2 non-spaces)
```
2 
 ╚
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=MiUyMCUwQSUyMCV1MjU1QQ__)
### Output
```
 /
/ 
```
### Explanation
In SOGL all lines except the last are replacing lines - it replaces everywhere in the continuing code the last character of the line with everything before it. SO the 1st line here is `replace space with 2 in the next line`.  
Then the next line - `2╚` gets executed: `2` pushes 2, and `╚` creates a diagonal of size 2.
[Answer]
# CBM BASIC v2.0 (8×8)
An improvement over [my previous answer](https://codegolf.stackexchange.com/a/60922/46220), using a completely different approach:
```
1s=56/8 
2?sP7); 
3?"?":: 
4s=s-+1 
5ifsgO2 
6?-8^6; 
7?sP1): 
       8
```
Output:
```
       ?
       ?
       ?
       ?
       ?
       ?
       ?
-262144 
```
[Answer]
## Ruby, ~~8x8~~ 7x7
```
 print(
 (?f+"\
 "*6+?\
 )*6).!
 $><<"\
 f"<<!1
;      
```
Output:
```
f      
f      
f      
f      
f      
f      
 ffalse
```
Previous version, 8x8 with 20 spaces:
```
  puts((
  "ff"+#
  ?\s*6+
  ?\n)*7
  );$><<
  ?\s*2+
  ?f;p:p
.!
```
Output:
```
ff     
ff     
ff     
ff     
ff     
ff
ff     
  ffalse
```
[Answer]
# [Pushy](https://github.com/FTcode/Pushy), 4x4 square
Non-competing as the language postdates the challenge:
**Code:**
```
 H32
2 C4
:" } 
\o/
```
**Outputs:**
```
d   
 d  
  d 
   d
```
[**Try it online!**](https://tio.run/nexus/pushy#@6/gYWzEZaTgbMJlpaRQq8AVk6///z8A)
Because whitespace is irrelevant in Pushy, the code is easily arranged to match the negative of its output. The actual program looks like this:
```
H      \ Push char 100, 'd'
32 2C  \ Push char 32, a space, and make 2 extra copies
       \ We now have the string 'd   '
4:     \ 4 times do:
  "    \   Print the string
   }   \   Cyclically shift it right, once
```
Backslashes begin a comment, so the trailing `\o/` is just there to complete the negative, and look cool. 
---
Alternatively, for the same score, we can have the following solutions:
```
Code    Output
 35;    #
3 2j     #
2C 4      #
:"}        #
K 36     #
33 2      #
Ct4        #
 :}"    #
```
[Answer]
# Haskell, 10 × 10
```
main=let{ 
0&c='\32' 
!c;n&c=c! 
'\32'>>(n 
-1)&c;a!b 
=putStrLn 
$(b<$[1.. 
10])++[a] 
}in(9&'*' 
         )
```
Defines a helper function `a ! b` that prints a line of the form `bbbbbbbbba`, and a recursive function `n & c` that prints `n` lines of the form `ccccccccc␣` followed by one line of the form `␣␣␣␣␣␣␣␣␣c`.
Uses `<$` (`fmap const`, again) on a range to repeat a character. Note that `<$` is only available without imports since GHC 7.10, which post-dates this challenge. ~~I am not entirely sure if this makes this submission noncompeting.~~
Nothing really exciting with the choice of layout or algorithm here; I didn't have a lot of bytes to spare and it's just fortunate one can get the line breaks to occur around the `putStrLn` the way they did.
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `j`, 3x3 square
```
 3ƛ
S ↳
3↲ 
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=j&code=%203%C6%9B%0AS%20%E2%86%B3%0A3%E2%86%B2%20&inputs=&header=&footer=)
[Answer]
## Perl, 6x6 (26 non-spaces)
I spent a whlie looking through these and was sure there would be a Perl solution smaller than 7x7 somehow... A very fun challenge! This solution requires `-E`.
```
say+( 
$"x5, 
"5$/" 
)x5,5 
x5,$" 
     ;
```
### Usage:
```
perl -E 'say+( 
$"x5, 
"5\n" 
)x5,5 
x5,$" 
     ;'
```
### Output:
```
     5
     5
     5
     5
     5
55555 
```
[Answer]
# CBM BASIC v2.0 (9×9)
```
0dA8,7,6 
1dA5,4, 3
2dA2,1 ,0
3rEs: rem
4?sP s)::
5:? "*";:
6p =8---s
7 ?sPp):?
 8ifsgO3:
```
Output:
```
        *
       * 
      *  
     *   
    *    
   *     
  *      
 *       
*        
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 x 4 (12 non-spaces)
```
 4=þ
¢ +⁴
¢+ ⁴
¢ỌY
```
[Try it online!](https://tio.run/##y0rNyan8/1/BxPbwPq5DixS0HzVuAdLaChD64e6eyP//AQ "Jelly – Try It Online")
Output:
```
!   
 !  
  ! 
   !
```
This was pretty fun.
### How it works
```
 4=þ    Link 1 (nilad): Generate an identity matrix of size 4
¢ +⁴    Link 2 (nilad): Add 16 to above
¢+ ⁴    Link 3 (nilad): Add 16 again
¢ỌY     Main link (nilad): Convert the above to ASCII chars, and join by newline
```
Easy part: Jelly ignores whitespaces (as long as only one-byte builtins are used).
Hard part: Each line in Jelly is a separate link (or function), so it's not very short to spread a constant statement in multiple lines. Using a string literal is a good candidate, but no idea how to generate the negative.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~7x7~~ 8x8
EDIT: Previous version had incorrect behaviour.
```
 main(i)
{ for(;i
<9 ;pri\
ntf ("%\
*d%" "*\
c",i, 1,
9-i,10 )
,i++);} 
```
[Try it online!](https://tio.run/##BcE7CoAwDADQPacIhUI/Kdix1KN0kUglg1WKm3j2@B6ng1kVz02GEw8v9mu6KrAWrPeUBuPp6IxtEHZr0IQGbEgIM0FJQnlBDyQx@vqh6g8 "C (gcc) – Try It Online")
[Answer]
# [PHP](https://php.net/), 11 x 11 square
```
 for($x=0;#
 $x<10;$x++
 ){echo('|'
 .#########
 str_repeat
 (chr(32),#
 10)."\n");
 }echo(chr(
 32).'----'
 .'------')
;          
```
Output:
```
|          
|          
|          
|          
|          
|          
|          
|          
|          
|          
 ----------
```
This was a nightmare. I don't think I can fit any smaller.
[Try it online!](https://tio.run/##K8go@G9jXwAkFdLyizRUKmwNrJW5FFQqbAwNrFUqtLW5FDSrU5Mz8jXUa9S5FPSUYYBLobikKL4otSA1sYRLQSM5o0jD2EhTByhuaKCppxSTp6RpzaVQC9YKkuRSAErrqesCAcgcMAPI1OSyVoCD//8B)
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 71 bytes
```
for(i=s 
='';71 >
++i;s +=
i%9? i%+
8?' ':+1
:[ '\n']
) ;print
 (s);;;;
```
[Try it online!](https://tio.run/##DcE7CoAwDADQPafIIlGCg5OfUj2IOogfiGItjQievvrePj2TzkH8nauXZQ3n5Y71jXG7QipWESyRKQtsgVmMIluQpO5QEoaqI6SGC2h6pMHRCBkaH8TdgKlm5hfjBw "JavaScript (SpiderMonkey) – Try It Online")
Why everyone do LU-RD diag?
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 15x15, 112 nonspace
```
 + + + + + + + 
+ [ - > + > + +
 + + + + + + + 
+ + + < < ] > +
 + > > + > > + 
< < [ < . [ - >
 > + < < ] > > 
[ - < < + + + >
 > ] > + + + + 
+ + + + + + + +
 + + + + + [ < 
] < < < < [ . >
 > + + > > + < 
< < < < ] > > >
 + ] a a a a a 
```
[Try it online!](https://tio.run/##ZY1BCoAwDATveUXuxb6g5COlhyoIIngQfH/sJrQqsqSkyWZnPut2rNeyq3L4iAJnnlhaiwr030OpqcBBZpTxEja5VfQcsmm3CxOm@HqO7Yuj3vlDbz5iqdi1U2LP7/Tk/AcnuC9ch1Rv "brainfuck – Try It Online")
```
++++++++[->+>++++<<]>++>>+>>+<<[    10 32(00)00 01 ; Old didn't care nonspaces
<.[->>+<<]>>[-<<+++>>]>             10 96 01 00(01)       10 96 16 0(-17)
+++++++++++++++++[<]<<<<        (00)10 96 01 00 18       (10)96 16 00 00
[.>>++>>+<<<<<]>>>+]                10 96(02)00 18        10 96(18)00 01
```
[Answer]
# Deadfish~, 10x10 square
```
 {(icdcccc
 ccccc{dd}
 ddc{d}){i
 ii}ii}cic
 cccccccch
 hhhhhhhhh
 hhhhhhhhh
 hhhhhhhhh
 hhhhhhhhh
h         
```
Outputs
```
!         
!         
!         
!         
!         
!         
!         
!         
!         
 !!!!!!!!!
```
# Explanation
```
{           repeat 10 times
(           skip following the first time (if accumulator is 0), so repeat x9
ic          increment (will be 32 once this is run , so 33, then print as '!'
dccccccccc  decrement (to 32) and print 9 times
{dd}dd      decrement to 10 for newline
c{d}        print and decrement to 0
)           end if
{iii}ii     increment accumulator to 32
}           end loop
c           print as character (' ')
iccccccccc  increment and print 9 '!'s
h           stop the program, anything after this is junk
```
[Try it online!](https://tio.run/##hcohDoBQDANQv1NUguBQZIWsGrn8s48hpnlpmoryOnnriaMKucnpzfC1J7kMZI@1pwzS6rjm0MIQ438GRtUL "Deadfish~ – Try It Online")
]