[Question]
  [
This is the robbers' thread. The cops' thread [goes here](https://codegolf.stackexchange.com/questions/99546/code-ladder-cops).
Write a code that has the same number of bytes as the cop post and where the revealed characters are identical. The code must produce `1` in its initial state, and produce the numbers `2, 3 ..` when single alterations are made.
The winner will be the robber that cracked the most posts.
**Example post:**
# MyLang, 9 bytes, 8 numbers (including link to answer), Cop's username.
Original code:
```
abc1efghi
```
Code that produces 1 - 8:
```
1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi
```
Explanations are encouraged. The exact format of the robber post is optional.
  
[Answer]
# Retina, 2 bytes, 10 numbers, by [Martin Ender](https://codegolf.stackexchange.com/a/99549/31625).
Original code:
```
1
```
This replaces the empty input by the number 1.
Code that produces 1 - 10 (showing newlines as `\n` for convenience):
```
1 : \n1
2 : \n1\n
3 : \n11\n
4 : \n111\n
5 : \n1111\n
6 : \n11111\n
7 : \n111111\n
8 : \n1111111\n
9 : \n11111111\n
10: \n111111111\n
```
For 2 and onwards, we count the number of empty strings in the previous stage. For 2, there is an empty string before and after the 1. For 3 there is an empty string before the ones, in between the ones and after the ones. This works all the way up to 10.
[Try it online](http://retina.tryitonline.net/#code=CjExMTExMTExMQo&input=)
[Answer]
# Perl, 12 bytes, 10 numbers, by [ais523](https://codegolf.stackexchange.com/a/99623/57100)
Original code:
```
____;say__-9
```
Code that produces 1 - 10:
```
wait;say$!-9
wait;say$!-8
wait;say$!-7
wait;say$!-6
wait;say$!-5
wait;say$!-4
wait;say$!-3
wait;say$!-2
wait;say$!-1
wait;say$!-0
```
Explanation: 
```
wait;         # waits for a child process to end (there is no child so it just returns)
     say      # put the following on the screen:
        $!    # current value of the C errno. In this case, ECHILD (No child processes)
              # which has a value of 10
          -9  # minus 9
```
[Answer]
# JavaScript, 30 bytes, 10 numbers, by [ETHproductions](https://codegolf.stackexchange.com/a/99565/41805).
Original code:
```
1: alert(Array(2).join(3).length)
```
Other numbers
```
 2: alert(Array(2).join(31).length)
 3: alert(Array(2).join(314).length)
 4: alert(Array(2).join(3141).length)
 5: alert(Array(2).join(31415).length)
 6: alert(Array(2).join(314159).length)
 7: alert(Array(2).join(3141592).length)
 8: alert(Array(2).join(31415926).length)
 9: alert(Array(2).join(314159265).length)
10: alert(Array(2).join(3141592653).length)
```
### Explanation
`Array(2)` creates an Array with two empty cells. The `.join` method joins all the elements in an Array using a delimiter, which converts it into a String. In the Original Code, the delimiter was `3`. This meant that the two empty cells in the Array are joined together used `3` as their delimiter. This evaluates `"3"`, without anything on either side of the `3` because the Array is empty. And since the `length` of `"3"` is `1`, this value is outputted to the console.
For the other numbers, I add 1 more digit to the delimiter that is joining the elements of the Array. Hence, this increases its length, thus `alert`ing with increasing values. Note that the numerical value of the delimiter is not important, only its length is.
## Snack Snippet!
**Note:** I used `console.log` instead of `alert` in my Snack Snippet for obvious reasons. Also, output from the console is display in the snippet.
```
console.log(Array(2).join(3).length)
console.log(Array(2).join(31).length)
console.log(Array(2).join(314).length)
console.log(Array(2).join(3141).length)
console.log(Array(2).join(31415).length)
console.log(Array(2).join(314159).length)
console.log(Array(2).join(3141592).length)
console.log(Array(2).join(31415926).length)
console.log(Array(2).join(314159265).length)
console.log(Array(2).join(3141592653).length)
```
[Answer]
# Octave, 17 bytes, 10 numbers, by [Stewie Griffin](https://codegolf.stackexchange.com/a/99604/24877)
```
original:
_i_(__i__(2_5_))
solution:
fix( 'i'-(2*52))
fix( 'j'-(2*52))
fix( 'k'-(2*52))
fix( 'l'-(2*52))
fix( 'm'-(2*52))
fix( 'n'-(2*52))
fix( 'o'-(2*52))
fix( 'p'-(2*52))
fix( 'q'-(2*52))
fix( 'r'-(2*52))
```
[Answer]
# Python 2, 17 bytes, 10 numbers, by [xnor](https://codegolf.stackexchange.com/a/99681/53748)
```
print len(['  '])
print len(*['  '])
print len(*['   '])
print len(*['    '])
print len(*['     '])
print len(*['      '])
print len(*['       '])
print len(*['        '])
print len(*['         '])
print len(*['          '])
```
**[repl.it](https://repl.it/EWpb)**
[Answer]
## Python 2, 9 bytes, 10 numbers, [xnor](https://codegolf.stackexchange.com/a/100036/21487)
```
print 8/8
print 18/8
print 28/8
print 38/8
print 38/7
print 38&7
print 31&7
print 31&72
print 31&73
print 31&74
```
[Answer]
# Perl, 14 bytes, 10 numbers, by [Dada](https://codegolf.stackexchange.com/a/99569/62131)
Original code:
```
say_!"___"%""_
```
Code that produces 1 - 10:
1. `say"!"+1#"%""r`
2. `say"!"+2#"%""r`
3. `say"!"+3#"%""r`
4. `say"!"+4#"%""r`
5. `say"!"+5#"%""r`
6. `say"!"+6#"%""r`
7. `say"!"+7#"%""r`
8. `say"!"+8#"%""r`
9. `say"!"+9#"%""r`
10. `say"1"+9#"%""r`
I have a feeling this isn't what you were going for.
[Answer]
# JavaScript, 22 bytes, 10 numbers, by [Arnauld](https://codegolf.stackexchange.com/a/99665/62131)
Original program:
```
alert(0_6_4_>_0_2_0_7)
```
Cracked:
1. `alert(0+6^42>101210^7)`
2. `alert(0+5^42>101210^7)`
3. `alert(0+4^42>101210^7)`
4. `alert(0+3^42>101210^7)`
5. `alert(0+2^42>101210^7)`
6. `alert(0+1^42>101210^7)`
7. `alert(0+0^42>101210^7)`
8. `alert(0+0^42>101210^8)`
9. `alert(0+0^42>101210^9)`
10. `alert(0+3^42>101210^9)`
The hard part is to deal with the `>`, which has a very low precedence. I tried changing it to an `>>`, but it's easiest to just absorb it by making it uselessly calculate a boolean false (the `42>101210` section) which is numerically 0, and just generate the numbers from 1 to 10 with operators with an even lower precedence than `>`. I used `^`, bitwise xor, because it can generate the numbers from 1 to 10 fairly easily (conveniently, the 6 and 7 in the original input let me simplify the expression down to `6^7` which is 1).
[Answer]
# JavaScript, 9 bytes, [Hedi](https://codegolf.stackexchange.com/a/99611/42545)
Original code:
```
alert(+1)
```
Modifications:
```
alert(1+1)   // 2
alert(2+1)   // 3
alert(3+1)   // 4
alert(4+1)   // 5
alert(5+1)   // 6
alert(6+1)   // 7
alert(7+1)   // 8
alert(8+1)   // 9
alert(9+1)   // 10
```
[Answer]
## Octave, 55 bytes, 10 numbers, [flawr](https://codegolf.stackexchange.com/a/99669/30688)
```
(o=@(O,o)(@(O,o)o{2-O} ) (0<O,{ (yo=O-1)+1,@()1}))(1,o)
```
The final `1` can be cycled up to 9, and then change the `+1` to `+2`.
[Answer]
## Python 3, 16 bytes, 10 numbers, by [Sp3000](https://codegolf.stackexchange.com/a/99869/16766)
This was fun.
```
print(?%??f?r?t)
print(1%0xfor t)
print(2%0xfor t)
...
print(8%0xfor t)
print(84%0xfor t)
print(85%0xfor t)
```
Exploits the fact (which I didn't know till now) that a hex literal ends as soon as a character that isn't `0-9a-fA-F` is encountered--thus `0xfor` is a very sneaky way to write `15 or`. After that, it was a matter of finding the right value congruent to 10 modulo 15.
[Answer]
## JavaScript, 22 bytes, 10 numbers by [Arnauld](https://codegolf.stackexchange.com/a/99643/9365)
**Original code**:
```
alert(__14_337__xc_de)
```
**Modified**:
```
alert(00140337-0xc0de) // 1
alert(00140337-0xc0dd) // 2
alert(00140337-0xc0dc) // 3
alert(00140337-0xc0db) // 4
alert(00140337-0xc0da) // 5
alert(00140337-0xc0d9) // 6
alert(00140337-0xc0d8) // 7
alert(00140337-0xc0d7) // 8
alert(00140337-0xc0d6) // 9
alert(00140337-0xc0d5) // 10
```
I'm guessing this isn't the intended solution, but I'm hoping it's not too far off...
[Answer]
# Octave, 32 bytes, 10 numbers, by [Luis Mendo](https://codegolf.stackexchange.com/a/99567/31516)
Original code:
```
nnz(isprime(floor(s=3):i*-2i))+1
```
Modified codes:
```
2:  nnz(isprime(floor(s=3):i*-3i))+1
3:  nnz(isprime(floor(s=3):i*-5i))+1
4:  nnz(isprime(floor(s=3):i*-9i))+1
5:  nnz(isprime(floor(s=3):i*-9i))+2
6:  nnz(isprime(floor(s=3):i*-9i))+3
7:  nnz(isprime(floor(s=3):i*-9i))+4
8:  nnz(isprime(floor(s=3):i*-9i))+5
9:  nnz(isprime(floor(s=3):i*-9i))+6
10: nnz(isprime(floor(s=3):i*-9i))+7
```
There are many ways to make modifications here (for instance `s=2` and `+0` in the beginning).
Edit: A more probable alternative:
```
nnz(isprime(floor(s=2):i*-2i))+0
nnz(isprime(floor(s=2):i*-2i))+1
nnz(isprime(floor(s=2):i*-2i))+2
nnz(isprime(floor(s=2):i*-2i))+3
nnz(isprime(floor(s=2):i*-2i))+4
nnz(isprime(floor(s=2):i*-2i))+5
nnz(isprime(floor(s=2):i*-2i))+6
nnz(isprime(floor(s=2):i*-2i))+7
nnz(isprime(floor(s=2):i*-2i))+8
nnz(isprime(floor(s=2):i*-2i))+9
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/), 11 bytes, 10 numbers, by [Oliver](https://codegolf.stackexchange.com/a/99579/41805)
Original code:
```
 1: 3628801zï0>
```
Other numbers
```
 2: 3628801zï0>>
 3: 3628801zï0>>>
 4: 3628801zï0>>>>
 5: 3628801zï0>>>>>
 6: 3628801zï0>>>>>>
 7: 3628801zï0>>>>>>>
 8: 3628801zï0>>>>>>>>
 9: 3628801zï0>>>>>>>>>
10: 3628801zï0>>>>>>>>>>
```
### Explanation
```
3628801                        # push this number
       z                       # find its reciprocal
        ï                      # round it to the nearest integer (becomes 0)
         0                     # push 0
          >>>>                 # increment by 1 for each `>` present (this is for 4)
                               # implicit output
```
To summarise it, push `3628801`, take its reciprocal and round that to the nearest integer (evaluates to `0`). Then increment the stack. TADA!
[Try it online!](http://05ab1e.tryitonline.net/#code=MzYyODgwMXrDrzA-&input=) For output = 1 Then add as many `>`s as you want depending on what number you want to output.
[Answer]
# JavaScript, 12 bytes, 10 numbers, [Hedi](https://codegolf.stackexchange.com/a/99617/42545)
Original code:
```
alert(+[+1])
```
2 through 10:
```
alert(+[1+1])
alert(+[2+1])
alert(+[3+1])
alert(+[4+1])
alert(+[5+1])
alert(+[6+1])
alert(+[7+1])
alert(+[8+1])
alert(+[9+1])
```
There's only so much you can do with this much code...
[Answer]
# Jelly, 7 bytes, 10 numbers, [Jonathan Allan](https://codegolf.stackexchange.com/a/99636/58765)
Original code:
```
“1‘ỌȮḊ‘
```
Then:
```
“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘
```
You can check the last one on [TryItOnline!](http://jelly.tryitonline.net/#code=4oCcMeKAmOKAmOKAmOKAmOKAmOKAmOKAmOKAmOKAmOG7jHbhuIrigJg&input=) 
---
Another way would be
```
“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘
```
[Answer]
# Octave, 21 bytes, 10 numbers, by [Stewie Griffin](https://codegolf.stackexchange.com/a/99654/24877)
The `fpr` was a nice misguidance=) But I love the `(1') -> 2(1') -> 2+(1')` sequence!
```
original:
disp(fpr___f__e_(_'_)     % original
disp(fprintf= e=(1'))     % my solution
disp(fprintf= e=2(1'))
disp(fprintf= e=2+(1'))
disp(fprintf= e=3+(1'))
disp(fprintf= e=4+(1'))
disp(fprintf= e=5+(1'))
disp(fprintf= e=6+(1'))
disp(fprintf= e=7+(1'))
disp(fprintf= e=8+(1'))
disp(fprintf= e=9+(1'))
```
[Answer]
# Hexagony, 7 bytes, 10 numbers, by [Martin Ender](https://codegolf.stackexchange.com/a/99771/57100)
Original:
```
1<@|!__
```
Code that produces 1 - 10:
```
1<@|!).
2<@|!).
3<@|!).
4<@|!).
5<@|!).
6<@|!).
7<@|!).
8<@|!).
9<@|!).
9<@|!).!
```
1: [Try it Online!](http://hexagony.tryitonline.net/#code=MTxAfCEpLg&input=)  
9: [Try it Online!](http://hexagony.tryitonline.net/#code=OTxAfCEpLg&input=)  
10: [Try it Online!](http://hexagony.tryitonline.net/#code=OTxAfCEpLiE&input=)
Here is the hex for the first 9 programs (where # is the number that you want to print):
```
 # <
@ | !
 ) .
```
The memory edge is just set to the value you want to print, deflected to the SE and printed.
And the hex for 10:
```
  9 < @
 | ! ) .
! . . . .
 . . . .
  . . . 
```
Here, I added a character to the end which increased the hex size. First, the memory edge is set to 9, the pointer is deflected to the SE, memory is incremented, wraps around, the pointer is deflected to the SW, the value is printed and the program ends.
---
Here is a second solution:
```
1<@|!$)
2<@|!$)
3<@|!$)
...
8<@|!$)
9<@|!$)
9#@|!$)
```
1: [Try it Online!](http://hexagony.tryitonline.net/#code=MTxAfCEkKQ&input=)  
9: [Try it Online!](http://hexagony.tryitonline.net/#code=OTxAfCEkKQ&input=)  
10: [Try it Online!](http://hexagony.tryitonline.net/#code=OSNAfCEkKQ&input=)
The hex for 1 - 9 (this time `*` is the number to print):
```
 * <
@ | !
 $ )
```
This works the same as 1 - 9 above.
The hex for 10:
```
 9 #
@ | !
 $ )
```
This hits `9` then `#` switched the instruction pointer to the lower right one, memory is incremented to 10, `$` jumps over the `!`, the pointer is reversed back east where it jumps over `)` and ends. 
[Answer]
# C#, 90 bytes, 10 numbers, [Scepheo](https://codegolf.stackexchange.com/a/99738/58765)
Original:
```
using ______________________________________________;class C{static void Main(){_______;}}
```
First:
```
using System;class D{public D(){Console.Write(+1);}};class C{static void Main(){new D();}}
```
Then:
```
using System;class D{public D(){Console.Write(1+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(2+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(3+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(4+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(5+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(6+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(7+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(8+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(9+1);}};class C{static void Main(){new D();}}
```
[Answer]
# Ruby, 81 bytes, 10 numbers, [histocrat](https://codegolf.stackexchange.com/a/99944/45268)
Original code:
```
x=##/=#%#
)
###x
```
Cracked:
```
x=/$/=~%q
)
p x
```
This was a tricky one. Many characters that were revealed turned out to be red herrings! `/` isn't division but part of a regex literal. `%` isn't mod but part of an uncommon string literal syntax. This program simply prints the length of a string delimited by newlines. The subsequent programs can be obtained by inserting additional characters in the second line. 
[Answer]
# Octave, 25 bytes, 10 numbers, by [Luis Mendo](https://codegolf.stackexchange.com/a/99582/24877)
```
mean(repmat(1,ones(1,1)))
mean(repmat(2,ones(1,1)))
mean(repmat(3,ones(1,1)))
mean(repmat(4,ones(1,1)))
mean(repmat(5,ones(1,1)))
mean(repmat(6,ones(1,1)))
mean(repmat(7,ones(1,1)))
mean(repmat(8,ones(1,1)))
mean(repmat(9,ones(1,1)))
```
[Answer]
# 아희(Aheui), 19 bytes, 10 numbers, by [JHM](https://codegolf.stackexchange.com/a/99581/25180)
Original code:
```
봃法희
반자뭉
```
Modified:
```
2
봃法희
반반뭉
3
봃法희
반밬뭉
4
봃法희
반밭뭉
5
봃法희
반발뭉
6
봃法희
반타뭉
7
봃法희
반밝뭉
8
봃法희
반밣뭉
9
봃法희
반밢뭉
10
봃法희
반다뭉
```
[Answer]
# Octave, 24 bytes, 9 numbers, [by flawr](https://codegolf.stackexchange.com/a/99605/31516)
```
max(repmat(1,ones(),1))%
max(repmat(2,ones(),1))%
max(repmat(3,ones(),1))%
max(repmat(4,ones(),1))%
max(repmat(5,ones(),1))%
max(repmat(6,ones(),1))%
max(repmat(7,ones(),1))%
max(repmat(8,ones(),1))%
max(repmat(9,ones(),1))%
```
**Octave, 24 bytes ~~9~~ 10 numbers**
Note: This crack is for the first version of the cop post (posted the wrong snippet), with the revealed code looking like this: `___a__repmat(__one__),__)`. The correct version is above.
Original code:
```
+mean(repmat(1,ones(),1))
```
Modified versions that print 2-10
```
1+mean(repmat(1,ones(),1))
2+mean(repmat(1,ones(),1))
3+mean(repmat(1,ones(),1))
4+mean(repmat(1,ones(),1))
5+mean(repmat(1,ones(),1))
6+mean(repmat(1,ones(),1))
7+mean(repmat(1,ones(),1))
8+mean(repmat(1,ones(),1))
9+mean(repmat(1,ones(),1))
```
[Answer]
# JavaScript, 15 bytes, 10 numbers, [ETHProductions](https://codegolf.stackexchange.com/a/99614/34388)
Original code:
```
alert( +"+1"+0)  // Prints 1
```
Programs:
```
alert( +"+1"+1)  // Prints 2
alert( +"+1"+2)  // Prints 3
alert( +"+1"+3)  // Prints 4
alert( +"+1"+4)  // Prints 5
alert( +"+1"+5)  // Prints 6
alert( +"+1"+6)  // Prints 7
alert( +"+1"+7)  // Prints 8
alert( +"+1"+8)  // Prints 9
alert( +"+1"+9)  // Prints 10
```
[Answer]
# Octave, 21 bytes, 9 numbers, [by flawr](https://codegolf.stackexchange.com/a/99608/31516)
I really enjoyed this one... Clever :)
```
a='repmat(1one'(1,8)
a='repmat(2one'(1,8)
a='repmat(3one'(1,8)
a='repmat(4one'(1,8)
a='repmat(5one'(1,8)
a='repmat(6one'(1,8)
a='repmat(7one'(1,8)
a='repmat(8one'(1,8)
a='repmat(9one'(1,8)
```
[Answer]
## *Acc!!*, 10 bytes, 9 numbers, by [DLosc](https://codegolf.stackexchange.com/a/99570/55508)
Original code :
```
Write 49+_
```
To produce the numbers 1 to 9 :
```
Write 49+_
Write 49+1
Write 49+2
Write 49+3
Write 49+4
Write 49+5
Write 49+6
Write 49+7
Write 49+8
```
49 is the ascii code of `1`. `_` contains 0 by default (so `49+_ = 1`). And `Write` prints the character corresponding to the ascii code of its argument. Pretty straight forward.
[Answer]
# Python 2, 49 bytes, 10 numbers, [AlexRacer](https://codegolf.stackexchange.com/questions/99546/code-ladder-cops/99622#99622)
Maybe (just maybe) the intended solution, but if so, plenty of bytes could have been golfed off:
```
y=10-6;s='0901100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0902100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0903100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0904100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0905100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0906100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0907100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0908100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0909100000';print int(s[8-8+y-2+0+0:y])
y=10-4;s='0909100000';print int(s[8-8+y-2+0+0:y])
```
[Answer]
## [Befunge-93](http://esolangs.org/wiki/Befunge), 11 bytes, 10 numbers, [James Holderness](https://codegolf.stackexchange.com/a/99648/8478)
```
905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@
```
[Try it online!](http://befunge.tryitonline.net/#code=OTA1OioqLX4tLkA&input=)
Probably not the intended solution.
What I did was get rid of the pesky 25 (`5:*`) by multiplying it by `0`. If we then put a `9` at the beginning then the outputs will be `9 - N` where need to generate `N` from a single command. The only issue is `-1` to get `10`, but trying to read an integer if there's no input conveniently pushes a `-1`.
[Answer]
# 05AB1E, 5 bytes, 10 numbers, by [Adnan](https://codegolf.stackexchange.com/a/99656/56258).
Original code:
```
…[==1
```
1-10:
```
…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T
```
**Explanation:**
```
…[==   3 char string
    1  Push number
```
[Answer]
# 05AB1E, 6 bytes, 10 numbers, [Adnan](https://codegolf.stackexchange.com/a/99667/58106)
Original code:
```
¼ [==q
```
Keep adding `¼`'s to output up to 10:
```
¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q
```
[Try it online](http://05ab1e.tryitonline.net/#code=wrzCvMK8wrzCvMK8wrzCvMK8wrwgWz09cQ&input=)
How it works:
```
¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit
```
]