Funciton/Brainfuckiton

╔╤═══╤═╤════════════════════════════════════════════════════════════════════════════╤═╤═══╤╗                       ║│ + ├─┘                                                                            └─┤, │║                        ║├─┬─┘       ╥─╖   ╥──╖  ╓──╖  ╥  ╥╖ ╥  ╥──  ╥  ╥  ╓──  ╥  ╓  ┬ ┌─┬─┐ ┌──┐ ┬┐ ┬       └─┬─┤║                        ║├─┤         ╟─╨╖  ╟─╥╜  ╟──╢  ║  ║╙╖║  ╟─   ║  ║  ║    ╟─╥╜  │   │   │  │ │└┐│         ├─┤║                        ║├─┴─┐       ╨──╜  ╨ ╙─  ╨  ╨  ╨  ╨ ╙╜  ╨    ╙──╜  ╙──  ╨ ╙─  ┴   ┴   └──┘ ┴ └┘       ┌─┴─┤║                        ║│ . ├─┐                                                                            ┌─┤ - │║                        ║└──┬┴─┴┬──────────────────────────────────────────────────────────────────────────┬┴─┴┬──┘║                        ╟───┤ < │   B R A I N F U C K    I N T E R P R E T E R    I N    F U N C I T O N   │ > ├───╢ ║ [ ├───┴──────────┬─────────────────────────────────┬─────────────────────────────┴───┤ ] ║                       ╟───┘   USAGE      │            FEATURES             │            LIMITATIONS          └───╢ ║ ──────────────  │  ─────────────────────────────  │  ─────────────────────────────────  ║                        ║                  │                                 │                                     ║                        ║  The input is    │  ►  Supports infinite tape in   │  ►  Infinite loop if the input      ║ ║ expected to be  │     both directions. │    does not contain '\r' or '\n'. ║                       ║  a space-        │  ►  Each cell is an arbitrary-  │  ►  Undefined behaviour if the      ║ ║ separated list  │     size signed integer. │    square brackets in the program  ║ ║ of integers,    │  ►  Inputs can be arbitrary-    │     don’t match up. ║                       ║  followed by     │     size signed integers. │ ►  A double-space in the list of   ║ ║ either a        │  ►  Negative numbers can start  │     integers is interpreted as an   ║ ║ CR ('\r') or a  │     with '−' (minus, U+2212)    │     extra zero. ║                       ║  LF ('\n'),      │     or '-' (hyphen, U+002D). │ ►  Undefined behaviour if the BF   ║ ║ followed by     │  ►  All non-BF characters in    │     program outputs a number that   ║ ║ the brainfuck   │     the program are ignored. │    is not a valid Unicode          ║ ║ program. │                                │     codepoint. ║                       ║                  │                                 │                                     ║                        ╚══════════════════╧═════════════════════════════════╧═════════════════════════════════════╝                                  ╔═══════════════════════════════════════════════════════════════════╗                                  ║  BRAINFUCKiton (main program)                                     ║ ╟───────────────────────────────────────────────────────────────────╢                                 ║  BF(s) = let (p, i) = BF↕(s, 1);                                  ║ ║   BF◊(›(›(›(›(BF■(›(p, 0), 0, BF0(p)), i), p), ℓ(p)), 0), 0, 0)  ║ ╟───────────────────────────────────────────────────────────────────╢                                 ║  Exercise to the reader: Why are we passing 1 into BF↕? ║                                 ╚═══════════════════════════════════════════════════════════════════╝                                           ┌───────────────────────────────┐                                           │                 ╔═══╗  ╔═══╗  │     ╓┬────╖                                           │                 ║ 1 ║  ║   ║  │  ┌──╫┘ ›! ╟──┐                                           │                 ╚═╤═╝  ╚═╤═╝  │  │  ╙─────╜  │                                           │                ┌──┴──╖   │    │  │   ┌───╖   │                                           ├────────────────┤ BF↕ ╟───┘    │  └───┤ › ╟───┘ │    ╔═══╗      ╘══╤══╝     ┌──┴──╖   ╘═╤═╝                                           │ ┌───╢ 0 ╟─────┐   │        │ BF0 ║     │ │ │  ╚═╤═╝     │   │        ╘══╤══╝                                           │ │  ┌──┴──╖  ┌─┴─╖ │ ┌───╖  ┌──┴──╖  ╔═══╗                                           │ └──┤ BF◊ ╟──┤ › ║ └─┤ › ╟──┤ BF■ ╟──╢ 0 ║ │   ╘══╤══╝  ╘═╤═╝   ╘═╤═╝  ╘══╤══╝  ╚═╤═╝                                           │      ┌───╖  ┌─┴──╖  ┌─┴──╖    │       │                                           │  ┌───┤ ℓ ╟──┤ ›! ╟──┤ ›! ║   │       │                                           └──┤   ╘═══╝  ╘════╝  ╘═╤══╝  ┌─┴─╖     │                                              │                    └──┬──┤ › ╟─────┘                                              └───────────────────────┘  ╘═══╝                 ╔═════════════════════════════════════════════════════════════════════════════════════════════════════════╗                 ║  MAIN BRAINFUCK INTERPRETER FUNCTION                                                                    ║ ╟───────────────────────────────────────────────────┬─────────────────────────────────────────────────────╢                ║  BF◊(z, l, r) =                                   │  a = length of the program                          ║ ║   let (d, y) = ‹(z);                             │  b = value of cell left of current cell             ║ ║   let (a, x) = ‹(y);                             │  c = value of current cell                          ║ ║   let (p, w) = ‹(x);                             │  d = current position in program                    ║ ║   let (i, t) = ‹(w);                             │  e = current position in program plus one           ║ ║   let (c, q) = ‹;(r);                            │  f = position in program after current instruction  ║ ║   let n = (p >> (21 × d)) & ¬(−1 << 21);         │  g = next input value to be read                    ║ ║   let (g, h) = ‹;(i);                            │  h = input list with one value removed              ║ ║   let j = n = ',' ? h : i;                      │  i = input list (input to the BF program)           ║ ║   let (b, k) = ‹;(l);                            │  j = input list after current instruction           ║ ║   let u = ɛ(t, d);                               │  k = left tape with first cell removed              ║ ║   let e = ♯(d);                                  │  l = left tape                                      ║ ║   let v = n = '>';                               │  m = left tape after current instruction            ║ ║   let w = n = '<';                               │  n = current instruction                            ║ ║   let m = v ? ›(l, c) :                         │  o = output generated by rest of the program        ║ ║           w ? k : l;                            │  p = program                                        ║ ║   let s = v ? q :                               │  q = right tape (not including current cell)        ║ ║           w ? ›(r, b) :                         │  r = right tape (including current cell)            ║ ║           n = '+' ? ›(q, ♯(c)) :                │  s = right tape after current instruction           ║ ║           n = '-' ? ›(q, ᴥ(c)) :                │  t = jump table (for square brackets)               ║ ║           n = ',' ? ›(q, g) : r;                │  u = program position to jump to                    ║ ║   let f = n = '[' ? c ? e : u :                 │  v = current instruction is '>'                     ║ ║           n = ']' ? c ? u : e : e;              │  w = current instruction is '<'                     ║ ║   let o = BF◊(›(›(›(›(t, j), p), a), f), m, s);  │  x = temporary variable for unsquishing data        ║ ║   d = a ? −1 :                                  │  y = temporary variable for unsquishing data        ║ ║     n = '.' ? c | (o << 21) : o                 │  z = squished data (everything but the tape)        ║ ╚═══════════════════════════════════════════════════╧═════════════════════════════════════════════════════╝                                                                                                                                   ╓┬────╖                                                                                  ┌─────────────────────────────────────────────────╫┘BF◊ ╟┐ ┌─┴─╖                                              ╙──┬──╜│          ┌─────────────────────────────────────────────────────────────────────┤ · ╟───────────┐                                      │   │          │                                                                     ╘═╤═╝           │                                      │   │        ┌─┴─╖                                                                   ┌─┴─╖         ┌─┴─╖                                    │   │     ┌──┤ · ╟───────────────────────────────────────────────────────────────────┤ · ╟──────┬──┤ · ╟─────────────────────────────────┐  │   │     │  ╘═╤═╝                                                                   ╘═╤═╝      │  ╘═╤═╝                                 │  │   │     │    │                                                                     ┌─┴─╖      │    │                                   │  │   │     │    │                                                                ┌────┤ ‹ ╟──────┘    │                                   │  │   │     │    │                                                              ┌─┴─╖  ╘═══╝         ┌─┴─╖                                 │  │   │     │    │                                                         ┌────┤ ‹ ╟────────────────┤ · ╟─────────────────────┐           │  │   │     │    │                                                       ┌─┴─╖  ╘═══╝                ╘═╤═╝                     │           │  │   │     │    │                                                  ┌────┤ ‹ ╟─────────────────────────┤                       │           │  │   │     │    │                                                ┌─┴─╖  ╘═══╝                         │                       │     ┌───╖ │  │   │     │    │                             ┌──────────────────┤ ‹ ╟───────────────────┐            │     ┌─────────────────┴─────┤ = ╟─┘  │   │     │    │                             │                  ╘═══╝                 ┌─┴─╖        ┌─┴─╖ ┌─┴─╖                     ╘═╤═╝    │   │     │    │                             │      ┌─────────────────────┐   ┌───────┤ · ╟────────┤ · ╟─┤ · ╟──────┐                │      │   │     │    │      ┌───────────────┐      │    ┌─┴─╖     ╔════╗  ┌───╖ │   │   ┌──┐╘═╤═╝┌──┐    ╘═╤═╝ ╘═╤═╝      │         ╔════╗ │      │   │     │ ┌──┴─╖  ┌─┴─╖             └──────┴────┤ · ╟──┐  ║ 44 ╟──┤ = ╟─┴───┘ ┌─┴─╖└──┴──┘┌─┴──╖ ┌─┴─╖ ┌─┴─╖      │         ║ −1 ║ │      │   │     │ │ >> ╟──┤ · ╟──────┬───┐  ╔═════════╗ ╘═╤═╝  │  ╚════╝  ╘═╤═╝  ┌────┤ ? ╟───────┤ ‹; ╟─┤ · ╟─┤ · ╟──┐   │         ╚══╤═╝ │      │   │     │ ╘══╤═╝  ╘═╤═╝     ┌┴┐  └──╢ 2097151 ║   │    │            │  ┌─┴─╖  ╘═╤═╝       ╘════╝ ╘═╤═╝ ╘═╤═╝  │   │ ╔════╗     │   │      │   │     │  ┌─┴─╖    │       └┬┘     ╚═════════╝   │    │            └──┤ · ╟────┘          ┌───────┘     │    │   │ ║ 46 ╟──┐  │   │      │   │   ┌─┴──┤ × ╟──┐ │   ┌────┴────────────────────┤    └────────────┐  ╘═╤═╝             ┌─┴─╖           │    │   │ ╚════╝  │  │   │      │   │   │    ╘═══╝  │ │   │           ╔════╗  ┌───╖ │ ┌───╖   ╔════╗  │  ┌─┴─╖           ┌─┤ · ╟───────────┘    │   │  ┌───╖  │  │   │      │   │   │   ╔════╗  │ │   │           ║ 93 ╟──┤ ≠ ╟─┴─┤ ≠ ╟───╢ 91 ║  └──┤ · ╟────┐      │ ╘═╤═╝                │   └──┤ = ╟──┘  │   │      │   │   │   ║ 21 ╟──┘ │   │           ╚════╝  ╘═╤═╝   ╘═╤═╝   ╚════╝     ╘═╤═╝    │      │   │                  │      ╘═╤═╝     │   │      │   │   │   ╚════╝ ┌──┴╖┌─┴─╖                 ┌─┴─╖   ┌─┴─╖   ┌───╖      ┌─┴─╖  ┌─┴─╖  ┌─┴─╖ │ ┌────────┐     ┌─┴─╖    ┌─┴─╖   ┌─┴─╖ │      │   │   └──────────┤ · ╟┤ · ╟────┐ ┌───╖ ┌────┤ ? ╟───┤ ? ╟───┤ › ╟──────┤ · ╟──┤ · ╟──┤ › ║ │ │        ├─────┤ · ╟────┤ ? ╟───┤ ? ╟─┘      │   │              ╘══╤╝╘═╤═╝  ┌─┴─┤ ♯ ╟─┤    ╘═╤═╝   ╘═╤═╝   ╘═╤═╝      ╘═╤═╝  ╘═╤═╝  ╘═╤═╝ │┌┴┐      ┌┴┐    ╘═╤═╝    ╘═╤═╝   ╘═╤═╝        │   │                 │   │    │   ╘═══╝ │    ┌─┴─╖   ┌─┴─╖     │          └┐   ┌─┴─╖  ┌─┴─╖ │└┬┘      └┬┘      └───┐    │       │          │   │                 │   │    │         │  ┌─┤ · ╟───┤ ? ╟──┐  │           └─┐ │ › ╟──┤ › ╟─┘ │     ┌──┴─╖  ╔════╗ │  ┌─┴─╖     │          │   │                 │   │    │       ┌─┴─╖│ ╘═╤═╝   ╘═╤═╝  │  └──────────┐  └┐╘═╤═╝  ╘═══╝ ┌─┴─╖ ┌─┤ << ╟──╢ 21 ║ └──┤ · ╟──┐  │          │   │                 │   │    │    ┌──┤ · ╟┤ ┌─┴─╖     │    │          ┌──┴──╖└──┘ ┌────────┤ · ╟─┤ ╘════╝  ╚════╝    ╘═╤═╝  │  │          │   │                 │   │    │    │  ╘═╤═╝└─┤ ? ╟───┬─┘    │  ┌───────┤ BF◊ ╟─────┘        ╘═╤═╝ └─────────────────────┘    │             │   │ │  │    │    │    │    ╘═╤═╝   │      │  │ ╔════╗╘══╤══╝                │                              │             │   │                 │   │    │    │    │    ┌─┴─╖   │      │  │ ║ 43 ║   │         ┌───╖     ├──────────┐                   │             │   │                 │ ┌─┴─╖┌─┴─╖┌─┴─╖  └────┤ · ╟───┘      │  │ ╚═╤══╝   │     ┌───┤ ᴥ ╟─────┘   ┌───╖  ├──┐                │             │   │ └─┤ · ╟┤ · ╟┤ · ╟─────┐ ╘═╤═╝         │  │ ┌─┴─╖    │     │   ╘═══╝     ┌───┤ ♯ ╟──┘  │                │             │   │                   ╘═╤═╝╘═╤═╝╘═╤═╝   ┌─┴─╖ └─┬──────────┘  │ │ ≠ ╟─┐┌─┴─╖ ┌─┴─╖         ┌─┴─╖ ╘═══╝   ┌─┴─╖              │             │   │                     │    │    │     │ ɛ ╟───┘ ┌───────────┘ ╘═╤═╝ └┤ ? ╟─┤ · ╟─────────┤ › ║    ┌───┤ · ╟───────┐      │             │   │                     │    │  ┌─┴─╖   ╘═╤═╝     │    ┌──────────┤    ╘═╤═╝ ╘═╤═╝   ┌───┐ ╘═╤═╝  ┌──┴─╖ ╘═╤═╝       │      │             │   │                     │    └──┤ · ╟─────┘       │    │ ╔════╗ ┌─┴─╖  ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │   ├────┤ ‹; ╟───┤         │      │             │   │                     │       ╘═╤═╝           ┌─┴─╖  │ ║ 44 ║ │ ≠ ╟──┤ ? ╟─┤ · ╟─┤ › ║ │ ┌─┴─╖  ╘════╝ ┌─┴─╖     ┌─┴─╖    │             │   │                     │       ┌─┴─╖    ┌──────┤ · ╟──┤ ╚══╤═╝ ╘═╤═╝  ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ └─┤ · ╟─────────┤ · ╟─────┤ · ╟────┘             │   │                     └───────┤ · ╟────┤      ╘═╤═╝┌─┴─╖  └─────┘    ┌─┴─╖ ┌─┴─╖   │     ╘═╤═╝         ╘═╤═╝     ╘═╤═╝                  │   │                             ╘═╤═╝    │        │  │ ≠ ╟─────────────┤ ? ╟─┤ › ║   ├───────┘             │         │                  ┌─┴─╖ │                               │      │      ┌─┴─╖╘═╤═╝  ╔════╗     ╘═╤═╝ ╘═╤═╝   │                     │         ├──────────────────┤ · ╟─┘                               │      │ ┌────┤ · ╟─┐└────╢ 45 ║     ┌─┴─╖   ├─────┘                     │         │                  ╘═╤═╝                               │      │ │    ╘═╤═╝ │     ╚════╝ ┌───┤ ? ╟───┘  ┌────────┐               │         │                    │                               │      │ │    ┌─┴─╖ │   ┌────────┘   ╘═╤═╝   ┌──┘      ┌─┴─╖           ┌─┴─╖       │                    │                               │      │ │ ┌──┤ ? ╟─┘   │            ┌─┴─╖ ┌─┴─╖ ┌─────┤ · ╟───────────┤ · ╟───────┘                    │                               │      │ │ │  ╘═╤═╝   ┌─┴─╖     ┌────┤ ? ╟─┤ › ║ │     ╘═╤═╝           ╘═╤═╝                            │                               │      │ │ │  ┌─┴─╖ ┌─┤ · ╟─┐   │    ╘═╤═╝ ╘═╤═╝ │     ┌─┴─╖             │                              │                               │      │ │ │ ┌┤ ? ╟─┘ ╘═╤═╝ │ ┌─┴─╖    └──┬──┘   │  ┌──┤ · ╟───┐         │                              │                               │      │ │ │ │╘═╤═╝   ┌─┴─╖ └─┤ · ╟─┐     └──────┘┌─┴─╖╘═╤═╝   ├─────────┘                              │                               │      │ │ │ │  └─────┤ · ╟─┐ ╘═╤═╝ └─────────────┤ › ║  │     │                                        │                               │      │ │ │ │        ╘═╤═╝ │ ┌─┴─╖               ╘═╤═╝  │     │                                        │                               │      │ │ │ └───────┬──┘   └─┤ · ╟──────────────┬──┘  ┌─┴──╖  │                                        │                               │      │ │ │       ┌─┴─╖      ╘═╤═╝              └──┬──┤ ‹; ║  │                                        │                               │      │ │ └───────┤ · ╟─────┬──┘                   │  ╘═╤══╝  │                                        │                               │      │ │         ╘═╤═╝     │                      │  ┌─┴─╖ ┌─┴─╖                                      │                               │      │ │ ╔════╗  ┌─┴─╖   ┌─┴─╖   ╔════╗           └──┤ · ╟─┤ · ╟──────────────────────────────────────┘                               │      │ │ ║ 62 ╟──┤ ≠ ╟─┬─┤ ≠ ╟───╢ 60 ║              ╘═╤═╝ ╘═╤═╝                               │      │ │ ╚════╝  ╘═══╝ │ ╘═══╝   ╚════╝                │     │                               │      │ │             ┌─┴─╖                             │     │                               │      │ └─────────────┤ · ╟─────────────────────────────┘     │                               │      │               ╘═╤═╝                                   │                               │      └─────────────────┘                                     │                               └──────────────────────────────────────────────────────────────┘      ┌─────────────────────────────────────────────────────────┬──────────────────────────────┐                             ╔═════════════════════════════════════════╗      │                                             ╓┬────╖     │                              │                             ║  Split input at the first newline and   ║ │                                            ╟┘BF↕ ╟─────┤    ┌───╖  ╔═══╗        ┌─────┴─────────────────────┐       ║  convert the first part into a list of  ║ │                                            ╙──┬──╜     └────┤ > ╟──╢ 0 ║      ┌─┴─╖                         │       ║  integers. The integers represent the  ║ │                                             ┌─┴─╖           ╘═╤═╝  ╚═══╝   ┌──┤ · ╟─────┐                   │       ║  input to the brainfuck program, the    ║ │                    ┌────────────────────────┤ · ╟─────────────┴────────────┘  ╘═╤═╝     │                   │       ║  rest is the brainfuck code. ║     │                     │       ╔═════════╗      ╘═╤═╝                          ┌────┴─┐     │                   │       ╟─────────────────────────────────────────╢      │                     │       ║ 2097151 ╟────┬───┴───────────┐                │ ┌┐ ┌─┴─╖   │                  ┌┴┐      ║  BF↕(b, a) =                            ║ │                    │       ╚═════════╝   ┌┴┐            ┌─┴─╖              └─┤├─┤ ? ╟───┴────┐             └┬┘      ║      let g = ¬a;                        ║ │                    │                     └┬┘  ┌─────────┤ · ╟────────────┐   └┘ ╘═╤═╝        │              │       ║      let s = a < 0;                     ║ │                    │                  ┌───┴───┘         ╘═╤═╝            │      ┌─┴─╖      ┌─┴─╖            │       ║      let c = b & ((1 << 21) − 1);       ║ │                  ┌─┴─╖              ┌─┴─╖               ┌─┴─╖            │ ┌────┤ · ╟──────┤ · ╟───────┐    │       ║      let (h, u) = ‹(s ? g : a);         ║ │             ┌────┤ · ╟──────────────┤ · ╟───────────────┤ · ╟─────────┐  └─┤    ╘═╤═╝      ╘═╤═╝       │    │       ║      let d = ›(u, (h × 10) + c − '0');  ║ │             │    ╘═╤═╝              ╘═╤═╝               ╘═╤═╝         │  ┌─┴─╖  ┌─┴─╖        │         │    │       ║      let f = s ? ›(u, ~h) : a;         ║ │             │      │   ╔════╗  ┌───╖  │  ┌───╖  ╔════╗  ┌─┴─╖  ┌───╖  ├──┤ · ╟──┤ · ╟──┐     │         │    │       ║      let n = c = ' ' ? ›(f, 0) :       ║ │             │      │   ║ 13 ╟──┤ ≠ ╟──┴──┤ ≠ ╟──╢ 10 ╟──┤ · ╟──┤ × ╟──┘  ╘═╤═╝  ╘═╤═╝  │     │         │    │       ║              c = '-' | c = '−' ? g :   ║ │             │      │   ╚════╝  ╘═╤═╝     ╘═╤═╝  ╚════╝  ╘═╤═╝  ╘═╤═╝ ┌───╖ │     ┌┴┐ ┌─┴─╖   │         │    │       ║              s ? ¬d : d;               ║ │             │      │             └────┬────┘            ┌─┴─╖    └───┤ + ╟─┘     │ ├─┤ ‹ ║   │         │    │       ║      let t = b >> 21;                   ║ │             │      │              ┌───┴─────────────────┤ · ╟──┐     ╘═╤═╝       └─┘ ╘═╤═╝   │         │    │       ║      let (p, i) = BF↕(t, n);            ║ │ ┌────┐      │      │     ┌───╖  ┌─┴─╖                   ╘═╤═╝  │     ┌─┴─╖  ┌───╖      │   ┌─┴─╖       │    │       ║      let e = c = '\r' | c = '\n';       ║ │ │  ┌─┴─╖  ┌─┴─╖  ┌─┴─╖ ┌─┤ ᴙ ╟──┤ ? ╟── ╔════╗ ┌────╖    │    │     │ − ╟──┤ › ╟──────┴───┤ · ╟──┐    │    │       ║      [program: e ? t : p,              ║ │ │  │ › ╟──┤ · ╟──┤ ? ╟─┤ ╘═══╝  ╘═╤═╝   ║ 21 ╟──┤ >> ╟────┘    │     ╘═╤═╝  ╘═╤═╝          ╘═╤═╝  │    │    │       ║       inputs:  e ? ᴙ(f) : i]           ║ │ │  ╘═╤═╝  ╘═╤═╝  ╘═╤═╝ │        ┌─┴─╖   ╚════╝  ╘═╤══╝         │    ╔══╧═╗  ┌─┴─┐            │    │    │    │       ╟─────────────────────────────────────────╢      │  │  ┌─┴─╖    │      │   │     ┌──┤ · ╟─────────────┴──┐         │    ║ 48 ║  │  ┌┴┐           │    │    │    │       ║                   input                 ║ │ │  │ ~ ║    │  ┌───┘   └───┐ │  ╘═╤═╝                │         │    ╚════╝  │  └┬┘           │    │    │    │       ║                     ↓                   ║      │  │  ╘═╤═╝    │  │  ╔════╗   │ │ ┌──┴──╖             ┌─┴─╖       │            │ ┌─┴─╖          │    │    │    │       ║                  ┌──┴──╖                ║      │┌─┴─╖  └──────┘  │  ║ 32 ║   │ └─┤ BF↕ ╟─────────────┤ ? ╟───────┘           └─┤ ? ╟──────────┘    │    │    │       ║   accumulator → ─┤ BF↕ ╟─ → BF inputs   ║ └┤ · ╟────────────┘ ╚═╤══╝   │   ╘══╤══╝             ╘═╤═╝                      ╘═╤═╝               │    │    │       ║                  ╘══╤══╝    (list)      ║ ╘═╤═╝              ┌─┴─╖  ┌─┴─╖  ┌─┴─╖                │                        ┌─┴─╖             ┌─┴─╖┌─┴─╖  │       ║                     ↓                   ║         │                 │ = ╟──┤ · ╟──┤ ? ╟─────────────────────────────────────────┤ ? ╟─────────────┤ · ╟┤ · ╟──┘       ║                BF program               ║ │                ╘═╤═╝  ╘═╤═╝  ╘═╤═╝                                         ╘═╤═╝             ╘═╤═╝╘═╤═╝          ╟─────────────────────────────────────────╢         │                   │      │    ┌─┴─╖  ╔═══╗                               ┌────┴────┐            │    │            ║  Exercise to the reader: This function  ║ │                  │      └────┤ › ╟──╢ 0 ║                   ╔══════╗  ┌─┴─╖     ┌─┴─╖  ╔════╗  │    │            ║  uses a trick to encode both a list of  ║ │                  │           ╘═══╝  ╚═══╝                   ║ 8722 ╟──┤ ≠ ╟──┬──┤ ≠ ╟──╢ 45 ║  │    │            ║  integers and an additional boolean in  ║ │                ┌─┴─╖                                        ╚══════╝  ╘═══╝┌─┴─╖╘═══╝  ╚════╝  │    │            ║  a single value (the accumulator). ║        └─────────────────┤ · ╟───────────────────────────────────────────────────────┤ · ╟───────────────┘    │            ║  How does it encode the extra boolean,  ║ ╘═╤═╝                                                      ╘═╤═╝                    │            ║  and what is its purpose? ║                            └────────────────────────────────────────────────────────┬──┘                      │            ╚═════════════════════════════════════════╝                                                                                      └─────────────────────────┘                                ┌─────────────────────────────────────────────────────────────────────┐                                │                                                          ╓┬────╖    │                              ┌─┴─╖                                  ┌─────────────────────╫┘BF■ ╟────┤         ╔══════════════════════════════════════╗ ┌───────────────┤ · ╟───────────────────────────┐   ┌─┴─╖                   ╙──┬──╜    │         ║  Computes the jump table of the      ║ │              ╘═╤═╝           ╔═════════╗     ├────┤ ‹ ╟───┐                  │       │         ║  brainfuck program: for every        ║ │                │             ║ 2097151 ╟──┬──┘    ╘═══╝   │                  │       │         ║  square-bracket character in the     ║ │                │             ╚═════════╝ ┌┴┐   ┌──────────┴─────────────┐    │       │         ║  brainfuck program, the resulting    ║ │                │       ╔════╗  ┌───╖     └┬┘ ┌─┴─╖ ┌───╖  ╔════╗        │    │       │         ║  list contains the index of the      ║ │                │       ║ 93 ╟──┤ = ╟──────┴──┤ · ╟─┤ = ╟──╢ 91 ║        │    │       │         ║  matching other square bracket. ║             │                 │       ╚════╝  ╘═╤═╝         ╘═╤═╝ ╘═╤═╝  ╚════╝        │    │       │         ╟──────────────────────────────────────╢              │               ┌─┴─╖               │         ┌───┘     │                ┌─┴─╖  │       │         ║  BF■(q, s, a) =                      ║ │            ┌─┤ · ╟┐              │         │ ┌───╖ ┌─┴─╖    ┌─────────┤ · ╟──┴────┐  │         ║      let (i, p) = ‹(q);              ║ │            │ ╘═╤═╝│      ┌───────┴─────┐   └─┤ › ╟─┤ · ╟────┘         ╘═╤═╝       │  │         ║      let (m, t) = ‹(s);              ║ │            │   │  │    ┌─┴─╖  ┌───╖  ┌─┴─╖   ╘═╤═╝ ╘═╤═╝         ┌──────┴──────┐  │  │         ║      let c = p & ((1 << 21) − 1);    ║ │   ┌───╖  ┌─┴─╖ │  ├────┤ · ╟──┤ ‹ ╟──┤ ? ╟─┐ ┌─┴─╖   │         ┌─┴─╖           │  │  │         ║      let l = c = ']';                ║ │ ┌─┤ ♯ ╟──┤ ↨ ╟─┘  │    ╘═╤═╝  ╘═╤═╝  ╘═╤═╝ └─┤ ? ╟───┘         │ ♯ ║           │  │  │         ║      let x = l ? t : s;             ║ │ │ ╘═══╝  ╘═╤═╝    │      │      └───┬──┘     ╘═╤═╝             ╘═╤═╝           │  │  │         ║      let y = ↨(a, m, ♯(i));          ║ │ │        ┌─┴─╖  ┌─┴─╖  ┌─┴─╖      ┌─┴─╖     ┌──┴──╖            ┌─┴─╖           │  │  │         ║      let z = ↨(y, i, ♯(m));          ║ │ └─────┬──┤ ↨ ╟──┤ · ╟──┤ ? ╟──────┤ · ╟─────┤ BF■ ╟────────────┤ › ║           │  │  │         ║      p ? BF■(›(p >> 21, ♯(i)),      ║              │        │  ╘═╤═╝  ╘═╤═╝  ╘═╤═╝      ╘═╤═╝     ╘══╤══╝            ╘═╤═╝           │  │  │         ║              c = '[' ? ›(s, i) : x,  ║              │        │  ┌─┴─╖    │      │        ┌─┴─╖      ┌─┴─╖             ┌─┴──╖  ╔════╗  │  │  │         ║              l ? z : a)              ║ │       │  │ ♯ ║    │      └──┬─────┤ · ╟──────┤ ? ╟──────┬──────┤ >> ╟──╢ 21 ║  │  │  │         ║        : a                           ║ │       │  ╘═╤═╝    │         │     ╘═╤═╝      ╘═╤═╝      │      ╘════╝  ╚════╝  │  │  │         ╟──────────────────────────────────────╢              │        │    └──────┘       ┌─┴─╖   ┌─┴─╖        │      ┌─┴─╖                    │  │  │         ║  Exercise to the reader: How does    ║ │       └───────────────────┤ · ╟───┤ · ╟───────────────┤ · ╟────────────────────┘  │  │         ║  this algorithm find all matching    ║ │                           ╘═╤═╝   ╘═╤═╝               ╘═╤═╝                       │  │         ║  brackets in just a single pass      ║ │                           ┌─┴─╖   ┌─┴─╖                 │                         │  │         ║  of the brainfuck program? ║             └────────────────────────────┤ · ╟───┤ · ╟─────────────────┘                         │  │         ╚══════════════════════════════════════╝                                           ╘═╤═╝   ╘═╤═╝                                           │  │                                             │       └─────────────────────────────────────────────┘  │                                             └────────────────────────────────────────────────────────┘                                                                                                     ╓┬────╖                                                                                                     ╟┘BF0 ║                ╔══════════════════════════════╗ ╓┬───╖             ╔═════════════════════════════╗       ╔════╗  ┌────╖        ╙──┬──╜                ║  zeroed list                 ║ ╟┘‹; ║             ║  safe shift                 ║       ║ 21 ╟──┤ >> ╟───────────┴──────────────┐    ╟──────────────────────────────╢ ╙─┬──╜             ╟─────────────────────────────╢       ╚════╝  ╘══╤═╝                          │    ║  (returns a list containing  ║              ┌────────┴─────┐           ║  (returns 0 and an empty    ║               ┌──┴──╖                         │    ║  all zeros of the same       ║ ┌────┴────┐        │           ║  list when input is empty)  ║               │ BF0 ║        ╔═══╗  ┌───╖     │    ║  length as the BF program)   ║ ┌──┴──┐     │      ┌──┴──┐        ╟─────────────────────────────╢               ╘══╤══╝   ┌────╢ 0 ╟──┤ ≠ ╟──┐  │    ╟──────────────────────────────╢      │   ┌─┴─╖  ┌─┴─╖  ┌─┴─╖   │        ║  ‹;(l) =                    ║                ┌─┴─╖  ┌─┴─╖  ╚═══╝  ╘═╤═╝  │  │    ║  BF0(p) =                    ║ │ ─┤ ? ╟──┤ ‹ ╟──┤ ? ╟─  │        ║    let (h, t) = ‹(l);       ║                │ › ╟──┤ ? ╟───────────┤   ├──┘    ║    (p = 0) | (p = −1)        ║ │  ╘═╤═╝  ╘═══╝  ╘═╤═╝   │        ║    [l ? h : l, l ? t : l]  ║                ╘═╤═╝  ╘═╤═╝ ╔════╗  ┌─┴─╖  │       ║      ? 0                    ║      └─────┘             └─────┘        ╚═════════════════════════════╝                ╔═╧═╗    │   ║ −1 ╟──┤ ≠ ╟──┘       ║      : ›(BF0(p >> 21), 0)    ║ ║ 0 ║   │   ╚════╝  ╘═══╝          ╚══════════════════════════════╝                                                                                        ╚═══╝