[Question]
  [
**Let us take a break from the brain-wrecking questions and answer some of the simpler ones**
You have recently read something extremely funny, and want to express your laughter to the world! *But how can you?*
## Task
You have to display the string:
`Lolololololololololololololololololololololololololololololololololololololololololololololololololololololololol...`
...to STDOUT.
The string *should be of infinite length*, or *will constantly be printed until the end of time*.
It is just as simple!
But remember, this is `code-golf`, so the source code must be as short as possible!
*Note: Some languages may throw errors since excecution can be timed out, or for other reasons. That is okay! It can be weird when you laugh forever!*
---
Good luck!
  
[Answer]
# [Python 3](https://docs.python.org/3/), 32 bytes
```
x='L'
while[print(end=x)]:x='ol'
```
[Try it online!](https://tio.run/##K6gsycjPM/7/v8JW3UedqzwjMyc1uqAoM69EIzUvxbZCM9YKKJOfo/7/PwA "Python 3 – Try It Online")
In Python 3, the `print` function by default has `end='\n'` to put a newline after what you print. Rather than changing that to the empty string, we stick the value `x` that we want to be printed there, and don't provide any value to be printed.
We stick the printing in the `while` loop condition. Since `print` returns `None` by default but this is Falsey and won't continue the loop, we wrap it in a singleton list to make it Truthy.
I had tried to stick an infinite iterator into `print` like `print(*iter(...),sep='')`, but it looks like Python will consume the whole iterable first and never actually print.
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), 8 bytes
```
"loL",<,
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//9Xysn3UdKx0fn/HwA "Befunge-98 (PyFunge) – Try It Online")
### How?
***`Lo`***:  
Initially the IP is going *east*.  
`"loL"` pushes *`l`*, *`o`* and *`L`* to the stack.  
`,` prints *`L`*, `<` turns the IP *west* and `,` prints *`o`*.
***`lo`*** forever:  
The IP is now moving *west*.  
`"loL"` pushes *`L`*, *`o`* and *`l`* to the stack.  
The IP wraps around and `,<,` prints *`l`* and *`o`*.  
*`L`* is left on the stack, but since we usually assume infinite resources, this is fine.
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), 5 bytes
```
L;o>l
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/9/HOt8u5/9/AA "Hexagony – Try It Online")
*Hexagony golfing language confirmed*
For some reason I was looking at [my own answer that prints "six" in 6 bytes](https://codegolf.stackexchange.com/a/195264/78410) and randomly thought "what if I remove `@`?", and exactly got this answer. 4 bytes is impossible because `Lol;` is already 4 bytes and it is impossible to alternate two chars and print both in a single loop without redirection.
Since there is no "halt" command in this program, the program flow looks like this: (It is recommended to read the docs on how `>` redirects the PC)
```
 A B
C > D
 E F
    [.....................................]  <= looping region
A B C > C B A D > A D B F > F C E A > D E F C > C ...
L ; o   o ; L l   L l ; .   . o . L   l . . o   o
^ ^     ^ ^         ^ ^
```
After the initial `L;`, `o;` and `l;` appear in the big loop in that order, therefore printing `Lololol...`.
[Answer]
# x86-16 machine code, IBM PC DOS, ~~13~~ 10 bytes
```
00000000: b04c cd29 0c20 3403 ebf8                 .L.). 4...
```
Listing:
```
B0 4C       MOV  AL, 'L'        ; start off with capital L
        PRINT:
CD 29       INT  29H            ; write to console
0C 20       OR   AL, 20H        ; lowercase it
34 03       XOR  AL, 3          ; swap between 'l' (0x6c) and 'o' (0x6f)
EB F8       JMP  PRINT          ; loop forever
```
[Try it online!](http://twt86.co/?c=sEzNKQwgNAPr%2BA%3D%3D)
A standalone PC DOS executable COM program. Output to console.
**-3 bytes thx to @nununoisy's very clever use of `XOR` to swap between `l` and `o`.**
Runtime:
[![enter image description here](https://i.stack.imgur.com/7AnHb.png)](https://i.stack.imgur.com/7AnHb.png)
*Forever and ever...*
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~41~~ 40 bytes
-1 byte thanks @ovs
```
+[+<[-<]>>++]<.>>+[+>+[<]>->]<[.---.+++]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1rbJlrXJtbOTls71kYPSEVrAzFQQNcu1iZaT1dXV08bKPX/PwA "brainfuck – Try It Online")
[Answer]
# [Labyrinth](https://github.com/m-ender/labyrinth), 7 bytes
```
762
8.3
```
[Try it online!](https://tio.run/##y0lMqizKzCvJ@P/f3MyIy0LP@P9/AA "Labyrinth – Try It Online")
Adds `623 % 256 == 111` to the previous answers below.
```
76   Push 76 and turn right (three-way junction)
.    Pop and print % 256 as char (L)
     Now the top is 0, so it should go straight, but instead it reflects to North
623  Turn right at 6 and push 623, going around the corners
.    Pop and print % 256 as char (o); go straight (three-way junction)
876  Push 876
     Loop forever, printing "lo"
```
---
## 10 bytes
```
76
8.1
 11
```
[Try it online!](https://tio.run/##y0lMqizKzCvJ@P/f3IzLQs@QS8HQ8P9/AA "Labyrinth – Try It Online")
Same idea, but using `876 % 256 == 108`. Turns out that going from an uppercase to lowercase is just a matter of prepending a 8 because `800 % 256 == 32`. At the center junction, the top is always 0 right after pop and print, so the IP goes straight (first from north to south, and second from east to west). All the numbers are corners which turn the IP 90 degrees, so the overall path is infinity-shaped `76.111.876.111. ...`. This form is one byte shorter than the naive square loop:
## 11 bytes
```
76.
8 1
.11
```
[Try it online!](https://tio.run/##y0lMqizKzCvJ@P/f3EyPy0LBkEvP0PD/fwA "Labyrinth – Try It Online")
---
## 14 bytes
```
 7
.63
1 1
11.
```
[Try it online!](https://tio.run/##y0lMqizKzCvJ@P9fwZxLz8yYy1DBkMvQUO//fwA "Labyrinth – Try It Online")
### How it works
First, the flow: the execution starts at the first valid command, which is `7` on top. The only junction is `6`, and since it causes the top of stack to be positive, the IP always turns right. It turns 180 degrees if it hits a dead end. So the sequence of commands executed in order is:
```
76.111.13676.111.13676.111. ...(runs indefinitely)
```
The stack has implicit zeros, and each of `0-9` adds that digit to the end of the top of the stack (in other words, `n` changes the top number `x` to `10x + n`). So the program is supposed to print the characters with charcode 76, 111, 13676, 111, 13676, ...
But 13676 is not `l`! Actually, Labyrinth's character output is done modulo 256.
How did I find such a number? With the path designed like this
```
 7
.6?
1 ?
11.
```
The problem is to find a number `??676` that is same as `l` (108) modulo 256. Note that, the equation `??xxx == yyy modulo 256` (`x` and `y` are givens and `?`s are unknown) is solvable if `xxx == yyy modulo 8`, and if so, it always has a solution within two or fewer digits, in particular `0 <= ?? < 32`. Since `676 % 8 == 108 % 8 == 4`, this is solvable, and the solution here is `13`.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + coreutils, 23 bytes
```
(echo L&yes)|tr "
y" ol
```
[Try it online!](https://tio.run/##S0oszvj/XyM1OSNfwUetMrVYs6akSEGJq1JJIT/n/38A "Bash – Try It Online")
### Explanation
We can generate infinite output using `yes`: without arguments, it outputs an infinite stream of `y` separated by newlines. `echo L & yes` outputs an `L` first, so our output stream looks like
```
L
y
y
y
y
```
To turn this into the output we want, we just need to change newline to `o` and `y` to `l`. `tr "\ny" ol` does this transliteration, and we can save a further byte by using an actual newline in place of `\n`.
[Answer]
# [Haskell](https://www.haskell.org/), 13 bytes
```
'L':cycle"ol"
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzX91H3Sq5MjknVSk/R@l/bmJmnoKtQkFpSXBJkYKKQtr/f8lpOYnpxf91I5wDAgA "Haskell – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), ~~51~~ ~~48~~ 47 bytes
```
a->{for(var s="L";;s="ol")System.out.print(s);}
```
[Try it online!](https://tio.run/##TY7BCoMwEETvfsWSU3LQHwj2LrQnj6WHrUaJVSPZNVDEb0@DiHQOM7A7PGbAgPnQfuKyvkfbQDMiETzQzrBlGSTZmY3vsDFQpROcCs62YEDW7O3cAyp9vPbDTxYxcoqjOiXiWX6@AH1P6o9WgYUSIua3rXNeBvRApbgLrVO4Uaj6S2ymwq1cLInBkpTeo74AtjBSiGvEHn8 "Java (JDK) – Try It Online")
thanks to [user](https://codegolf.stackexchange.com/users/95792/user) and [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king) helping me save 4 and 1 byte(s) respectively!
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 6 bytes
ovs' far superior 6-byter:
```
„Lo[?l
```
[Try it online!](https://tio.run/##yy9OTMpM/f//UcM8n/xo@5z//wE "05AB1E – Try It Online")
**Explanation:**
```
„Lo     Push 2-char string onto stack ('lo')
   [    Begin infinite loop
    ?   Output with no newline
     l  Push lowercase of top of stack ('Lo' -> 'lo')
        (Implicitly close infinite loop)
```
---
[05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
My pitiful 8-byter:
```
'L?„ol[?
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f3cf@UcO8/Jxo@///AQ "05AB1E – Try It Online")
It might still be golfable, perhaps if there's a way to compress 'Lol' even further.
**Explanation:**
```
'L        Push 'L' onto stack
  ?       Print without newline ('L')
   „ol    Push 2-char string onto stack ('ol')
      [   Loop Forever
       ?  Print without newline ('ol')
          (Implicitly close infinite loop)
```
[Answer]
# [Marbelous](https://github.com/marbelous-lang/docs/blob/master/spec-draft.md), 14 ~~31~~ bytes
```
6C
6F@0
@0/\4C
```
Marbelous is a language based on marble machines
* `@n` (`n` from `0` to `Z`) is a portal which teleport the marble to another portal with the same value
* `00`-`FF` initiate a marble with this value
* `/\` create a duplicate passing marble to it's left and right
* `..` is a noop
* marbles going out of the machine from the bottom are implicitly outputed
[interpretor](https://github.com/marbelous-lang/marbelous.py)
-17 bytes thanks to DLosc
[Answer]
# [Python 3](https://docs.python.org/3.8/), ~~37~~ 34 bytes
-3 thanks to xnor - noting that print may have no unnamed argument!
```
x='L'
while x:x=print(end=x)or'ol'
```
**[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/v8JW3UedqzwjMydVwdCqwragKDOvRCM1L8W2QjO/SD0/R/3/fwA "Python 3.8 (pre-release) – Try It Online")**
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/), 147 bytes
```
haha l-o-l funny!i saw a thingy,it was soo funny
o?what
i am crying
o?what
i am dying,literal CHOKING
dying r-n?goddamn
just see
ohhhhhh heh,lol ig
```
[Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?VcoxDgIhEIXhnlM8ezjDFhZqTPQM44LMGJZJgA3h9Kuula/83s/EhOTUJTzXnMdBUKmD0FhyHFYaOlVU1d9vdOpMzQhowVzGJ/oj/xWbpIVCCcfz/Xq5ncyuKC5PUb2nJZvXWhtqCEZ5HziwTZogcdse5N8)
In the form of a text conversation between two people collectively laughing at something they found online.
[Answer]
# PHP, 24 bytes
```
L<?php for(;;)echo'ol';
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 27 bytes
```
f(i){f(!printf("Lol"+!i));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1OzOk1DsaAoM68kTUPJJz9HSVsxU1PTuvY/UEQhNzEzT0NToZqLM01D05qLsyi1pLQoT8HAmqv2PwA "C (gcc) – Try It Online")
[![enter image description here](https://i.stack.imgur.com/XMD52.png)](https://i.stack.imgur.com/XMD52.png)
[Answer]
# [convey](http://xn--wxa.land/convey/), 10 bytes
```
['L'}'lo'}
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoiWydMJ30nbG8nfSIsInYiOjEsImkiOiIifQ==)
Visualization (separated)
[![Visualization (separated)](https://i.stack.imgur.com/mZP3O.gif)](https://i.stack.imgur.com/mZP3O.gif)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
”L⁾olȮ¿
```
A full program which prints an `L` then repeatedly prints `ol`.
**[Try it online!](https://tio.run/##y0rNyan8//9Rw1yfR4378nNOrDu0//9/AA "Jelly – Try It Online")**
### How?
```
”L⁾olȮ¿ - Main Link: no arguments
”L      - set the left argument to 'L'
      ¿ - while...
     Ȯ  - ...condition: print & yield the left argument
  ⁾ol   - ...do: set the left argument to "ol"
```
[Answer]
# [Hexagony](https://github.com/m-ender/hexagony), ~~11~~ 6 bytes
-5 thanks to @Bubbler
```
L;o;l;
```
[Try it online!](https://tio.run/##y0itSEzPz6v8/9/HOt86x/r/fwA "Hexagony – Try It Online")
```
  L ;   Executed once: Set memory to 'L' (76) and print
 o ; l  Executed repeatedly: Set memory to 'o' (111), print, set memory to 'l' (108)
  ; .   Executed repeatedly: Print
```
After the first row is executed once, the second and third rows are repeatedly executed, infinitely printing `ol`.
[Answer]
# [Cascade](https://github.com/GuyJoKing/Cascade), ~~22~~ 14 bytes
```
@o|
.l@
L"^
/"
```
[Try it online!](https://tio.run/##S04sTk5MSf3/3yG/hksvx4HLRymOS1/p/38A "Cascade – Try It Online")
-8 thanks to Jo King.
[Answer]
### **x86-16 machine code MS-DOS - 23 bytes**
This answer inspired by [640KB](https://codegolf.stackexchange.com/questions/210976/lolololololololololololol/210988#210988) answer.
```
 000000: B4 02 B7 4C 8A D7 CD 21  B2 6F CD 21 8A D7 80 F2   ...L...!.o.!....
 000010: 20 CD 21 EB F3 CD 20                                .!... 
```
Listing:
```
      6 0100  B4 02              MOV AH, 02H
      7 0102  B7 4C              MOV BH, 'L'
      8 0104  8A D7              MOV DL, BH
      9 0106  CD 21              INT 21H
     10
     11 0108                 PRINT:
     12 0108  B2 6F              MOV DL, 'o'
     13 010A  CD 21              INT 21H
     14 010C  8A D7              MOV DL, BH
     15 010E  80 F2 20           XOR DL, 20H
     16 0111  CD 21              INT 21H
     17 0113  EB F3              JMP PRINT
     18
     19 0115  CD 20              INT 20H
```
Output:
[![output](https://i.stack.imgur.com/98Iw5.png)](https://i.stack.imgur.com/98Iw5.png)
[Answer]
# [braingasm](https://github.com/daniero/braingasm), 12 bytes
```
76.28524+[.]
```
Prints the byte streams `76` once, then `28524` forever
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), two answers of 33 bytes
```
BEGIN{for(;;)printf s=s?"ol":"L"}
```
and
```
BEGIN{for(printf"L";;)printf"ol"}
```
[Try it online!](https://tio.run/##SyzP/v9f2cnV3dOvOi2/SMPaWrOgKDOvJE2h2LbYXik/R8lKyUeplgtJCUQeKApXC1JW@/8/AA "AWK – Try It Online") (uncomment a line to try it)
First answer: a simple ternary condition upon the assignment of the variable `s`. On the first run, it is evaluated as false. As it is not assigned yet, it is parsed as a null string, which is false.
Second answer: just a for loop.
[Answer]
# [Flipbit](https://github.com/cairdcoinheringaahing/Flipbit), ~~35~~ ~~30~~ 28 bytes
*Thanks to Bubbler for -5 by shortening the loop*
*Thanks to ovs for -2 by being big smort*
```
^>>>^>^>>.<<<<<^>>>[>^>^.<<]
```
[Try it online!](https://tio.run/##S8vJLEjKLPn/P87Ozi4OCO30bEAAxI0GCQC5sf//AwA)
Prints `L`, gets the tape set up for `l`, then makes use of the fact that `o` and `l` differ by only their two least significant bits to create a short loop to print both characters repeatedly.
[Answer]
# [Forte (Forter)](https://github.com/judofyr/forter), 25 bytes
```
5PRINT"ol";:LET5=1
1PUT76
```
[Try it online!](https://tio.run/##S8svKkn9/980IMjTL0QpP0fJ2srHNcTU1pDLMCA0xNzs/38A "Forte – Try It Online")
### Explanation
An undefined behavior exploit courtesy of [Jo King](https://codegolf.stackexchange.com/users/76162/jo-king):
```
1 PUT 76
```
Print an `L` character.
```
5 PRINT "ol"; : LET 5 = 1
```
Print `ol` without a final newline, and set 5 to 1.
Apparently, this overwrites the former line 1 with the former line 5, and thus (lacking an `END` statement) the `PRINT "ol";` line is executed repeatedly forever. But I don't really understand how this works--especially since it only works if you write line 5 before line 1, not [vice versa](https://tio.run/##S8svKkn9/98wIDTE3IzLNCDI0y9EKT9HydrKxzXE1Nbw/38A)...
---
Here's a **44-byte** version that doesn't use any undefined behavior:
```
1PUT76
5PRINT"ol";:LET6=6+0
6LET0=2:LET5=5+2
```
[Try it online!](https://tio.run/##S8svKkn9/98wIDTE3IzLNCDI0y9EKT9HydrKxzXEzNZM24DLDMgysDUCCZjammob/f8PAA "Forte – Try It Online")
### Explanation
```
1 PUT 76
```
Print an `L` character.
```
5 PRINT "ol"; : LET 6 = 6 + 0
```
Print `ol` without a final newline, and set 6 to 6.
```
6 LET 0 = 2 : LET 5 = 5 + 2
```
Set 0 to 2, and set 5 to 7.
```
~~5~~ 7 PRINT "ol"; : LET 6 = 6 + ~~0~~ 2
```
Print `ol` again, and set 6 to 8.
```
~~6~~ 8 LET ~~0~~ 2 = 2 : LET ~~5~~ 7 = ~~5~~ 7 + 2
```
Set 2 to 2, and set 7 to 9.
```
~~5~~ ~~7~~ 9 PRINT "ol"; : LET ~~6~~ 8 = ~~6~~ 8 + ~~0~~ 2
```
Print `ol` again, and set 8 to 10.
And so on forever.
[Answer]
# [Vim](https://www.vim.org) `+startinsert`, ~~14~~ 11 bytes
```
ol<C-v><C-r>"<C-o>ddL<C-r>"
```
[Try it online!](https://tio.run/##K/uf@T8/R0xIiT8lxUdI6f9/AA)
In TIO, when the recursive register expansion (RRE) times out, nothing is outputted since it didn't finish expanding. In Vim, you may not see anything right away since the console might freeze during the RRE, but if you `Ctrl`+`C`, you can stop the expansion and see that it does work.
Explanation:
```
                              # '+startinsert' flag - start vim in insert mode; TIO equivalent is 'i' in the header
ol<C-v><C-r>"                 # Insert 'ol<C-r>"'
              <C-o>           # Run normal mode command, then return to insert mode:
                   dd         #   Delete 'ol<C-r>"' into unnamed register
                     L        # Insert 'L'
                      <C-r>"  # Insert unnamed register, which recursively expands to 'ol' + unnamed register
```
[Answer]
Neither beats Johan du Toit's answer, but I enjoy that they are full programs, plus I like the way the longjmp answer works.
# [C (gcc)](https://gcc.gnu.org/), 39 bytes
As straight forward as it gets, uses `for` initializer to print `L`, then it's `ol`s from there on out.
```
main(){for(printf("L");printf("ol"););}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7M6Lb9Io6AoM68kTUPJR0nTGsbOzwFyNK1r//8HAA "C (gcc) – Try It Online")
# [C (gcc)](https://gcc.gnu.org/), 50 bytes
Definitely more fun, use an int array as jmp\_buf, then add the return of setjmp to the string pointer so that the first iteration adds 0, then pass 1 to longjmp so the rest add 1 and skip the `L`.
Thanks to jdt for -4 bytes!
```
j[9];main(){printf("Lol"+setjmp(j));longjmp(j,1);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z8r2jLWOjcxM09Ds7qgKDOvJE1DySc/R0m7OLUkK7dAI0tT0zonPy8dzNYx1LSu/f8fAA "C (gcc) – Try It Online")
[Answer]
# [Pyramid Scheme](https://github.com/ConorOBrien-Foxx/Pyramid-Scheme), 200 bytes
```
  ^     ^
 / \   / \
/out\ /do \
-----^-----^
    / \   ^-
   /chr\ / \
  ^-----/out\
 / \   ^-----^
/76 \ / \   ^-
-----/chr\ / \
    ^-----/chr\
   / \   ^-----
  /111\ / \
  -----/108\
       -----
```
[Try it online!](https://tio.run/##TY1LCoAwDET3OcVcoMRu1MOUgqhQF0Xxs/D0tTF@OouQDO@R5Vy7OA1m68MYx5QAD4knMFxe8iSej92BhznvRuJ1EhQQ3sjBfVjdrUgjuVX6INW4qeF@UcFC/WTpqPghyTdba19WQVu1KuJpUroA "Pyramid Scheme – Try It Online")
This *seems* to be the shortest way that I can find. This language isn't easy to golf in.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 8 bytes
```
p\L#p"ol
```
[Try it online!](https://tio.run/##K6gsyfj/vyDGR7lAKT/n/38A "Pyth – Try It Online")
## Explanation
```
p\L#p"ol
p\L        : print "L"
   #       : while True:
    p"ol   :     print "ol"
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), 5 bytes
```
L,{ǪȽ
```
[Try it online!](https://tio.run/##y05N///fR6f6@KoTe///BwA "Keg – Try It Online")
Finally! A reasonable use for the push'n'print commands!
## Explained
* Print the letter "L" (`L,`)
* While true: (`{`)
* ---- Print the letter "o" (`Ǫ`)
* ---- Print the letter "l" (`Ƚ`)
[Answer]
# [Flobnar](https://github.com/Reconcyl/flobnar), 18 bytes
```
og,!<
\l@>\<
2:L!_
```
[Try it online!](https://tio.run/##S8vJT8pLLPr/Pz9dR9GGKybHwS7GhsvIykcx/v///7pF/3UzAQ "Flobnar – Try It Online") (requires the `-i` flag)
## Explanation
Flobnar is a 2D language where expressions are laid out geometrically. For example, for a program that computes the number 10, you might write:
```
5
+  @
5
```
Here, `@` indicates the entry point for the program, and has the effect of evaluating the term to its west; `+` evaluates the terms to the north and south and returns their sum; etc.
The basic idea for this program is to embed the characters 'o', 'l', and 'L' in the source code at coordinates `(0, 0)`, `(1, 1)`, and `(2, 2)` respectively. Execution proceeds roughly like this:
```
def step(n):
    step(!n if (!putchar(get(n, n))) else "impossible since putchar() returns 0")
step(2)
```
Here's what the program looks like ungolfed:
```
o    >>>>v
 l   ^ \ < \ @
  L    v   2
     :!_
  :
  g , !<
  :
```
See [the specification](https://github.com/catseye/Flobnar) for more detailed information about what each term does.
]