supposedly/bf.ruel.rb Secret

## bf.ruel.rb
@NUTSHELL bf

Brainfuck.

: +  {Plus}
: -  {Minus}
: ]  {RBrack}
: [  {LBrack}
: <  {LAngle}
: >  {RAngle}
: .  {Dot}
: ,  {Comma}

: Plain pointer  {Pointer}
: Pointer +  {PointerPlus}
: Pointer -  {PointerMinus}
: Pointer [  {PointerRBrack}
: Pointer <  {PointerLAngle}
: Pointer >  {PointerRAngle}
: Pointer .  {PointerDot}
: Pointer ,  {PointerComma}
: Westbound backtracking pointer  {WestPointer}

: Northbound no-op {NorthNOP}

: Northbound +  {NorthPlus}
: Northbound -  {NorthMinus}
: Northbound ]  {NorthRBrack}
: Northbound <  {NorthLAngle}
: Northbound >  {NorthRAngle}
: Northbound .  {NorthDot}
: Northbound ,  {NorthComma}

: Westbound +  {WestPlus}
: Westbound -  {WestMinus}
: Westbound ]  {WestRBrack}
: Westbound <  {WestLAngle}
: Westbound >  {WestRAngle}
: Westbound .  {WestDot}
: Westbound ,  {WestComma}

: Eastbound +  {EastPlus}
: Eastbound -  {EastMinus}
: Eastbound ]  {EastRBrack}
: Eastbound <  {EastLAngle}
: Eastbound >  {EastRAngle}
: Eastbound .  {EastDot}
: Eastbound ,  {EastComma}

: Southbound ,  {SouthComma}

: Eastward-pointing shadow cell  {EastShadow}
: Westward-pointing shadow cell  {WestShadow}

: Westbound shadow +  {WestShadowPlus}
: Westbound shadow -  {WestShadowMinus}
: Westbound shadow ]  {WestShadowRBrack}
: Westbound shadow <  {WestShadowLAngle}
: Westbound shadow >  {WestShadowRAngle}
: Westbound shadow .  {WestShadowDot}
: Westbound shadow ,  {WestShadowComma}

: Eastbound shadow +  {EastShadowPlus}
: Eastbound shadow -  {EastShadowMinus}
: Eastbound shadow ]  {EastShadowRBrack}
: Eastbound shadow <  {EastShadowLAngle}
: Eastbound shadow >  {EastShadowRAngle}
: Eastbound shadow .  {EastShadowDot}
: Eastbound shadow ,  {EastShadowComma}

: Pointer delay state  {DelayedPointer}

: Data pointer    {DataPointer}
: Data-pointer +  {DataPointerPlus} == "data-output prompter"
: Data-pointer -  {DataPointerMinus}
: Data-pointer ]  {DataPointerRBrack}
: Data-pointer <  {DataPointerLAngle}
: Data-pointer >  {DataPointerRAngle}
: Data-pointer .  {DataPointerDot}
: Data-pointer ,  {DataPointerComma}

:          {Data}  Data
:       {DataOut}  Data turned output signal; reverts to data on next generation
:  {FinalDataOut}  Data-born output signal that will not extend westward anymore
:       {ZeroOut}  Vacuum turned output signal; reverts to vacuum on next
:  {FinalZeroOut}  Vacuum-born output signal that will not extend westward anymore

:  {DataPlus}  Plus sign (incrementor) moving through data
: {DataMinus}  Minus sign (decrementor) moving through data

: Second pointer delay state  {DelayedPointer2}  (down here b/c poor planning lol)

: eastbound YES signal   {EastLoop} (not 0, keep looping) from data pointer after testing for r-bracket
: westbound YES signal   {WestLoop}
: southbound YES signal  {SouthLoop}
: eastbound NO signal    {EastBreak} (is 0, continue)
: westbound NO signal    {WestBreak}
: southbound NO signal   {SouthBreak}
: west shadow holding southbound NO   {WestShadowBreak}
: west shadow holding southbound YES  {WestShadowLoop}
: east shadow holding southound NO    {EastShadowBreak}
: east shadow holding southbound YES  {EastShadowLoop}

: Input                 {NorthInput}
: Input head            {InputHead}, which covers the input tape & directs input toward the data pointer
: Input traveling east  {EastInput}

: misc state {Blank1}
: misc state {Blank2}
: eastbound misc state  {BlankEast}

: blank input  {Input0}
: {FreshInput} "Uninitialized" input data; this is only here for ease of storage in RLE format,
    because otherwise the vertical input tape is very unfriendly to Golly. It moves diagonally to
    the southeast until there’s something above it
: {FreshInput0}  Uninitialized \x00 input, same as above
: {FreshInputHead} Uninitialized input head, same as above

: Yet another pointer delay state just to absolutely be sure of no timing conflicts  {DelayedPointer3}
: Loop-skipping pointer  {PointerSkip} (opposite of WestPointer)


+ To use:
  Start with this template.
    x = 5, y = 4, rule = bf
    2.qJ$4.pR$rM$4.I!
  - Enter a BF program from left to right, using cellstates 1-8, starting in the dead cell immediately southeast of
    the bottommost live one.
  - Initialize data as diagonal, northwest-leaning unary stacks of state-66 cells, starting each stack in the row
    immediately above the topmost live cell.
  - Initialize input as vertically-stacked vertical stacks of state-84 cells, starting in and going south from the
    cell immediately below the westmost live one and with individual inputs delimited by state-85 cells.
    An input of \x00 can be represented using a single state-90 cell in lieu of the state-84 ones.
  - (Alternatively, should you wish to make your program friendlier to RLE encoding, you may initialize input as
    horizontal (west-pointing) stacks of state-91 cells, delimited by state-93 cells and using state 92 for \x00;
    the input tape will right itself automatically once the simulation starts.)

+ An example:
x = 19, y = 5, rule = bf
4.qJ$6.pR$2rSrM$6.I$7.H2DF2AEBCFGC!


@TABLE
anyPrgm = (Plus..Comma)
prgm = anyPrgm - (LBrack, RBrack)
vac = (0, anyPrgm)

northbound = (NorthPlus..NorthComma)
northboundNOP = (northbound, NorthNOP)
pointerOps = (PointerPlus..PointerComma) - PointerRBrack
northboundOps = northbound - NorthRBrack
westbound = (WestPlus..WestComma)
eastbound = (EastPlus..EastComma)

westshadows = (WestShadowPlus..WestShadowComma, WestShadow)
eastshadows = (EastShadowPlus..EastShadowComma, EastShadow)

datapointers = (DataPointerPlus..DataPointerComma)

vacdata = (0, Data)
data = (Data..DataMinus)

# Move uninitialized input data into proper position
(FreshInput, FreshInput0, FreshInputHead), E live, SE..NE any; 0 -> SE[0]
(FreshInput, FreshInput0, FreshInputHead), N live, NE..NW any; [0: (NorthInput, Input0, InputHead)]

#########################################################
##### INITIAL TELESCOPING OF BRACKET-ENCLOSED STUFF #####
#########################################################

# move program cell down if it has a closing bracket to its east
(prgm, RBrack), E RBrack, SE..NW vac, N..NE 0; 0 -> S[0]

# move program cell down if the cell to its east is below it
(prgm, RBrack), SE anyPrgm, S..E vac; 0 -> S[0]

## (NOTE: The above two groups aren't even necessary but symmetry finishes sooner) ##

# move program cell down if it has an opening bracket to its west
(prgm, LBrack), W LBrack, any, 0, NE..SW vac; 0 -> S[0]

# move program cell down if the cell to its west is below it
(prgm, LBrack), SW anyPrgm, W..S vac; 0 -> S[0]

# special-casing for ][, but could probably be handled above
LBrack, E..SE vac, S 0, SW RBrack, W..NE 0; 0 -> S:LBrack
RBrack, SE LBrack, 0, vac, vac, NW..E 0; 0 -> S:RBrack

# if a bracket has nothing in its mouth, assume it needs to travel south
# to catch up to a different level
# In the same vein, spawn a bracket if there's an empty cell between a bracket (N) and
# a prgm tape bit (SW/SE)
LBrack, N..SW 0, W vac, NW vac; 0 -> S:LBrack
RBrack, NE..E vac, SE..N 0; 0 -> S:RBrack

# if the above happens, move the now-hanging-one-lvl-too-high prgm-tape data south
prgm, E prgm, 0, 0, SW RBrack, 0, NW..NE 0; 0 -> S[0]  # ]x
prgm, SE LBrack, 0, 0, W prgm, NW..E 0; 0 -> S[0]  # x[


################
##### Data #####
################

### Data-pointer transformations ###
DataPointer, W eastbound, NW..SW any; [W: datapointers]
DataPointer, E westbound, SE..NE any; [E: datapointers]
# If a loaded shadow is directly below data pointer, pretend it's the same as a signal
DataPointer, S (westshadows-WestShadow, eastshadows-EastShadow), SW..SE any; [S: datapointers*2]

DataPointerMinus, N..NW any; DataPointer -> N:DataMinus
DataPointerPlus, N..NW (Data, any-Data); DataPointer -> N[(DataPlus, Data, ...)]
(DataPointerRAngle, DataPointerLAngle), N..NW any; 0 -> E[0: (DataPointer, _)]  W[0: (_, DataPointer)]

# Test to see whether there is data above the data pointer -- if yes, send back a LOOP signal ('keep looping'), and if no, send a BREAK ('stop looping')
DataPointerRBrack, N 0, NE..SE any, S (0, WestShadow, EastShadow), SW..NW any; DataPointer -> W[S: (_, WestShadowBreak, EastShadowBreak)]
DataPointerRBrack, N live, NE..SE any, S (0, WestShadow, EastShadow), SW..NW any; DataPointer -> W[S: (_, WestShadowLoop, EastShadowLoop)]
# we can't send a signal from north to south directly (would exceed lightspeed) so we put it to the west first as a two-step sort of thing; this does delay things by one gen however
(WestShadow, EastShadow), NW (WestShadowBreak, EastShadowBreak, WestShadowLoop, EastShadowLoop), N DataPointer, NE..W any; [NW] -> NW:0  W:0
# continue on
WestRBrack, W DataPointer, NW (0, data), N..SW any; [NW: (EastBreak, EastLoop, ...)]
EastRBrack, NE (0, data), E DataPointer, SE..N any; [NE: (WestBreak, WestLoop, ...)]

# Reroute west-/eastbound yes/no signals to the south because we need to get them to the program-tape pointer
# ((not relevant at all but i am so proud of how nutshell just takes this and spits out a working translation with no issue))
(WestShadow, EastShadow), N (WestBreak, EastBreak, WestLoop, EastLoop), NE..NW any; [N: (WestShadowBreak, EastShadowBreak, WestShadowLoop, EastShadowLoop)] -> N:0  NW[N: (0, _, 0, _)]  NE[N: (_, 0, _, 0)]
(WestShadowBreak, EastShadowBreak, WestShadowLoop, EastShadowLoop), N..NW any; [0: (EastShadow, WestShadow, EastShadow, WestShadow)] -> S[0: (SouthBreak, SouthBreak, SouthLoop, ...)]

# Finally, the r-brack receives the southbound yes/no signal from above
# If it's BREAK ('yes'), delete the waiting pointer and move it up to where it can continue traveling
# if it's LOOP ('no'), turn the waiting pointer into a westbound one to send it back to the appropriate l-brack
RBrack, N (SouthBreak, SouthLoop), NE..NW any; [0] -> N[(PointerRBrack, 0)]  W[N: (0, WestPointer)]

any, SW LBrack, W Blank1, NW..S any; NorthRBrack -> W:Blank2
WestPointer, W LBrack, NW..SE any, S (LBrack, prgm), SW any; [S: (Blank1, pointerOps)] -> W:LBrack
WestPointer, N..NW any; 0 -> W:WestPointer  N:NorthNOP

(WestBreak, WestLoop), N..NW any; 0 -> W[0]
(EastBreak, EastLoop), N..NW any; 0 -> E[0]

# Input
# make the comma signal stay put so the data pointer knows where to send the go-poll-for-input request (to have it reach the shadow cell)
WestComma, E 0, SE..SW any, W DataPointer, NW..NE any; Blank1  # just need a random nonmoving state
EastComma, E DataPointer, SE..SW any, W 0, NW..NE any; Blank2  # just need a random nonmoving state
# when input is requested, get the data pointer to zero the current cell,
DataPointerComma, N Data, NE..NW any; [0] -> N:DataMinus
DataPointerComma, N 0, NE..NW any; DataPointer  # blank cell's cue
# then once done tell the shadow cell to go poll for input
## if nothing to south, send it in appropriate direction
Blank1, W DataPointer, NW 0, N..S any, SW 0; 0 -> S:EastComma
Blank2, NE 0, E DataPointer, SE 0, S..N any; 0 -> S:WestComma
## elif shadow cell to south, stay put and do something stupid to give it the signal regardless
#### (this could be merged into the above transition but I'm lazy)
DataPointerComma, N 0, NE..SE any, S (WestShadow, EastShadow), SW..NW any; DataPointer -> SW:EastComma
# Also have these misc cells not destroy the shadow if it's to their south
(Blank1, Blank2), S WestShadow, SW..SE any; 0 -> S:WestShadow  SW:EastComma
(Blank1, Blank2), S EastShadow, SW..SE any; 0 -> S:EastShadow  SW:EastComma
## shadow cell receiving go-poll-for-input signal: (none of those commas would ever appear above it otherwise so we can always assume this'll be the cause)
## on receiving the signal it stays put and sends a comma to the west to ask the input-tape head for its stuff
(EastShadow, WestShadow), N..NE any, E WestComma, SE..SW any, W 0, any; [0] -> S:WestComma
(EastShadow, WestShadow), N..NE any, E 0, SE..SW any, W EastComma, any; [0] -> S:WestComma
# Input head doubles as data delimiter so have it move east appropriately to move data with
InputHead, N 0, NE NorthInput, E..NW any; 0 -> N:InputHead  # if it's the next up
0, (NorthInput, Input0), NE..SE any, InputHead, SW..NW any; InputHead  # if it's farther down
InputHead, N InputHead, NE..NW any; 0
# Input head is otherwise invincible
InputHead, N..NW any; [0]
# When the west comma finds the input head,
# move the comma down one to let the input (if any) know it's there
InputHead, NE WestComma, E..N any; [0] -> N:0  E:WestComma
Input0, NE WestComma, E..N any; InputHead
# Move input up and then send it back to the shadow cell
NorthInput, NE (WestComma, NorthInput), E..SE any, S..N any; 0 -> E:NorthInput
NorthInput, W InputHead, NW..SW any; 0 -> N:EastInput
(NorthInput, Input0), N..SE 0, S any, SW..NW any; 0 -> N[0]
# When shadow cell receives eastbound input, relay it as an "inc" signal
DataPointer, S (WestShadow, EastShadow), SW EastInput, W..SE any; DataPointerPlus
(EastShadow, WestShadow), W EastInput, NW..SW any; [0] -> N[0: (EastPlus, WestPlus)]
# When it receives the "we're done" signal, restore the program-tape pointer & send it on its way
(EastShadow, WestShadow), W BlankEast, NW..SW any; [0] -> S:SouthComma
0, W Blank1, NW SouthComma, N..SE any, S LBrack, SW Comma; Blank2 -> W:NorthRBrack  # emulate l-brack test from below
Blank1, N SouthComma, NE any, E (RBrack, prgm, 0), SE..NW vac; Pointer -> NE[E: (NorthRBrack, _, ...)]
# Also move eastbound input eastward
EastInput, N..NW any; 0 -> E:EastInput
# Send a "we're done" signal when there's no data or none left
InputHead, E (WestComma, NorthInput), SE..NE any; [0] -> SE:Blank1
# Move "we're done" signal
Blank1, W 0, NW InputHead, N..SW any; 0 -> N:Blank1
Blank1, W InputHead, NW 0, N..SW any; 0 -> N:BlankEast
BlankEast, N..NW any; 0 -> E:BlankEast

### Actual handling of data ###
DataPointerDot, N..NW any; DataPointer -> N[(0, _, ...)]  # don't output if there's nothing to output
# Output
Data, S DataPointerDot, SW..SE any; DataOut
vacdata, E 0, SE any, S (ZeroOut, DataOut), SW..NE any; [0: (FinalZeroOut, FinalDataOut)]
(FinalZeroOut, FinalDataOut), N..NW (vacdata, any-vacdata); [0: vacdata] -> N[(FinalZeroOut, FinalDataOut, _, ...)]

DataOut, N..NW (vacdata, any-vacdata); Data -> N[(ZeroOut, DataOut, _, ...)]
(ZeroOut, DataOut), N..NW (vacdata, any-vacdata); [0: vacdata] -> N[(ZeroOut, DataOut, _, ...)]  NE[(_, DataOut, _, ...)]

# inc/dec instructions
Data, SW DataMinus, W..S any; [NE: (0, DataMinus, ...)]
vacdata, SW DataPlus, W..S any; [0: (Data, DataPlus)]
0, SW DataPlus, W..S any; [NE: (Data, DataPlus, ...)]

DataMinus, SW 0, W..S any; [NE: (0, Data, ...)]
DataMinus, NE 0, E..N any; 0
(DataPlus, DataMinus), N..NW any; Data


#######################
##### SHADOW CELL #####
#######################

# If shadow is touching data pointer, flip direction before moving to it
EastShadow, NW DataPointer, N..W any; WestShadow
WestShadow, NE DataPointer, E..N any; EastShadow
eastshadows, SE northboundNOP, S..NW any, N DataPointer, NE..E any; 0 -> E[SE: westshadows]
westshadows, SW northboundNOP, W..NW any, N DataPointer, NE..S any; 0 -> W[SW: eastshadows]

# If a northbound cell is coming at shadow from a corner, move toward it & load self with it
eastshadows, SW northboundNOP, W..S any; 0 -> W[SW: eastshadows]
westshadows, SW northboundNOP, W..S any; 0 -> W[SW: westshadows]

eastshadows, SE northboundNOP, S..E any; 0 -> E[SE: eastshadows]
westshadows, SE northboundNOP, S..E any; 0 -> E[SE: westshadows]

# If it's coming from right below, just load without moving
eastshadows, S northboundNOP, SW..SE any; [S: eastshadows]
westshadows, S northboundNOP, SW..SE any; [S: westshadows]

# A "loaded" shadow cell turns into a normal one and releases its signal
eastshadows, N..NW any; EastShadow -> N[0: (eastbound, _)]
westshadows, N..NW any; WestShadow -> N[0: (westbound, _)]

# override northbound-signal transitions from ptr-movement section
(EastShadow, WestShadow), N..NW any; [0]


############################
##### Pointer MOVEMENT #####
############################

# Stop moving after reaching a comma or l-brack
PointerComma, E (RBrack, vac), SE..NE any; Blank1 -> NE:0  # just needs a random non-moving state, so blank_1 works
## l-brack test stuff
(Pointer, pointerOps), SE LBrack, S anyPrgm-Comma, SW..E any; NorthRBrack -> E:Blank2  # send out a test signal
NorthRBrack, N northbound, NE..NW any; Blank1 -> N:0
(Blank1, Blank2), E Blank2, SE..NE any; [0: (Blank2, NorthRBrack)]
### for most cases:
Blank2, NW (SouthLoop, SouthBreak), N..SE any, S LBrack, SW..W any; [NW: (Pointer, PointerSkip)] -> W:0  N:NorthNOP
### and for when it's on an l-brack that's right after a first l-brack:
Blank2, N (SouthLoop, SouthBreak), NE..SE any, S LBrack, SW..NW any; [N: (Pointer, PointerSkip)]
### and one more edge case:
Blank2, NE (SouthLoop, SouthBreak), E..SE any, S LBrack, SW..N any; [NE: (Pointer, PointerSkip)] -> E:0
## keep moving eastward till pointer_skip finds an r-brack
PointerSkip, SE (RBrack, 0), S..E any; 0 -> E[SE: (Pointer, PointerSkip, ...)]  NE:NorthNOP
# Also don't put out north-bound signals after hitting r-brack
pointerOps, N..NE any, E RBrack, SE..NW any; Pointer -> NE:NorthRBrack
# But elsewhere do so as normal
(Pointer, pointerOps), any, 0, vac, SE (LBrack, prgm), S..SW vac, (LBrack, vac), any; DelayedPointer -> N[0: (_, northboundOps)]
DelayedPointer, N..NW any; DelayedPointer2
DelayedPointer2, N..NW any; DelayedPointer3  # need 3 delay states to give data pointer breathing room from both sides
DelayedPointer3, any, 0, vac, SE (LBrack, prgm), S..SW vac, (LBrack, vac), any; 0 -> E[SE: (Pointer, pointerOps)]
LBrack, N Pointer, NE..E 0, SE (LBrack, prgm), S..NW any; LBrack -> N:NorthNOP  E[SE: (Blank2, pointerOps)]
0, S Blank2, SW LBrack, W NorthNOP, NW..SE 0; NorthRBrack
0, S NorthRBrack, SW 0, W NorthNOP, NW..SE any; NorthRBrack -> S:0
# Replicate the above NE-output behavior if a bare pointer is on top of an RBrack with another to its east
# (this needs a special case; nothing happens otherwise)
PointerRBrack, E (RBrack, any), SE..NE any; Pointer -> NE[E: (NorthRBrack, _, ...)]

# Make north_r_brack wait 4 generations before going up to absolutely make sure it won't collide badly with the data pointer
NorthRBrack, W northbound, NW..SW any; [0] -> N:0
NorthRBrack, NW northbound, N..W any; Blank1 -> N:0  # random non-interfering state (any would do)
Blank1, S RBrack, SW..SE any; RBrack
RBrack, S RBrack, SW..SE any; NorthRBrack
# Move signals
(NorthRBrack, northboundNOP), N..NW any; 0 => N[0]
(WestRBrack, westbound), N..NW any; 0 => W[0]
(EastRBrack, eastbound), N..NW any; 0 => E[0]
(SouthComma, SouthBreak, SouthLoop), N..NW any; 0 -> S[0]

# Pointer stops after reaching end
(Pointer, PointerRBrack, pointerOps), E..SE 0, S anyPrgm-LBrack, SW..NE any; 0 -> E:Pointer
# ...with some edge-case handling
Pointer, E Pointer, SE 0, S RBrack, SW..NE any; 0  # avoid double pointer if r-brack is the last character
Pointer, W Blank1, NW..S 0, SW any; 0  # avoid punching through the prgm tape if comma is the last character

@COLORS
000: 0
FFF: FinalZeroOut
FF0: InputHead, FreshInputHead


@ICONS
?  0FF .. FFF
0:  000
1:  FFF
2:  0A0
3:  C00
4:  666
5:  CB0
6:  0AF

#C empty space/shadow
#C NorthNOP, EastShadow..EastShadowComma, WestShadowBreak..EastShadowLoop, Blank1..BlankEast
x = 13, y = 13, rule = bf
3.7A$.3A5D3A$.A9DA$2A2D.3D.2D2A$A2D3.D3.2DA$A3D5.3DA$A4D3.4DA$A3D5.3D
A$A2D3.D3.2DA$2A2D.3D.2D2A$.A9DA$.3A5D3A$3.7A!

#C Left bracket
#C LBrack
x = 9, y = 15, rule = bf
2.7D$.8D$3D4A2D$2D5A2D$2D2A5D$2D2A5D$2D2A2D$2D2A2D$2D2A2D$2D2A5D$2D2A
5D$2D5A2D$3D4A2D$.8D$2.7D!

#C Right bracket
#C RBrack, NorthRBrack, WestRBrack, EastRBrack
x = 9, y = 15, rule = bf
7D$8D$2D4A3D$2D5A2D$5D2A2D$5D2A2D$3.2D2A2D$3.2D2A2D$3.2D2A2D$5D2A2D$
5D2A2D$2D5A2D$2D4A3D$8D$7D!

#C Plus sign
#C Plus, NorthPlus, WestPlus, EastPlus
x = 15, y = 15, rule = bf
5.5D$4.7D$4.2D3A2D$4.2D3A2D$.5D3A5D$6D3A6D$2D11A2D$2D11A2D$2D11A2D$6D
3A6D$.5D3A5D$4.2D3A2D$4.2D3A2D$4.7D$5.5D!

#C Minus sign
#C Minus, NorthMinus, WestMinus, EastMinus
x = 15, y = 7, rule = bf
.13D$15D$2D11A2D$2D11A2D$2D11A2D$15D$.13D!

#C Left angle bracket
#C LAngle, NorthLAngle, WestLAngle, EastLAngle
x = 15, y = 13, rule = bf
10.5D$8.7D$6.5D2A2D$4.5D4A2D$2.5D4A4D$5D4A6D$3D4A6D$5D4A6D$2.5D4A4D$
4.5D4A2D$6.5D2A2D$8.7D$10.5D!

#C Right angle bracket
#C RAngle, NorthRAngle, WestRAngle, EastRAngle
x = 15, y = 13, rule = bf
5D$7D$2D2A5D$2D4A5D$4D4A5D$6D4A5D$2.6D4A3D$6D4A5D$4D4A5D$2D4A5D$2D2A
5D$7D$5D!

#C Comma
#C Comma, NorthComma, WestComma, EastComma, SouthComma
x = 13, y = 15, rule = bf
2.9D$.11D$3D7A3D$2D9A2D$2D9A2D$2D9A2D$2D9A2D$2D9A2D$3D8A2D$.6D4A2D$3.
4D4A2D$.5D4A3D$.2D6A4D$.11D$2.9D!

#C Period
#C Dot, NorthDot, WestDot, EastDot
x = 13, y = 13, rule = bf
4.5D$2.9D$.4D3A4D$.2D7A2D$3D7A3D$2D9A2D$2D9A2D$2D9A2D$3D7A3D$.2D7A2D$
.4D3A4D$2.9D$4.5D!

#C "V" shape; instruction pointer
#C Pointer..WestPointer, PointerSkip
x = 11, y = 12, rule = bf
4A3.4A$4A3.4A$5A.5A$.4A.4A$.9A$2.7A$2.7A$3.5A$3.5A$4.3A$4.3A$5.A!

#C Darker "V" shape; delayed pointer
#C DelayedPointer, DelayedPointer2, DelayedPointer3
x = 11, y = 12, rule = bf
4D3.4D$4D3.4D$5D.5D$.4D.4D$.9D$2.7D$2.7D$3.5D$3.5D$4.3D$4.3D$5.D!

#C Data pointer
#C DataPointer..DataPointerComma
x = 11, y = 11, rule = bf
4.3E$4.3E$3.5E$3.5E$2.7E$2.7E$.9E$.4E.4E$5E.5E$4E3.4E$4E3.4E!

#C Inert data
#C Data
x = 13, y = 13, rule = bf
7.4E$6.6E$5.8E$4.9E$3.10E$2.11E$.11E$11E$10E$9E$8E$.6E$2.4E!

#C Active forward-moving data
#C DataOut, FinalDataOut, DataPlus
x = 15, y = 15, rule = bf
2.13A$3.A10BA$4.A9BA$4.A9BA$3.A10BA$2.A11BA$.A12BA$A13BA$A13BA$A13BA$
.A9B2ABA$2.A7BA2.2A$3.A5BA4.A$4.A3BA$5.3A!

#C Active backward-moving data
#C DataMinus
x = 15, y = 15, rule = bf
7.3A$6.A3FA$A4.A5FA$2A2.A7FA$AF2A9FA$A13FA$A13FA$A13FA$A12FA$A11FA$A
10FA$A9FA$A9FA$A10FA$13A!

#C Check mark ('yes', aka 'loop')
#C EastLoop..SouthLoop
x = 13, y = 13, rule = bf
13B$13B$11BAB$10B2AB$9B3AB$8B3A2B$2BA4B3A3B$2B2A2B3A4B$2B6A5B$3B4A6B$
4B2A7B$13B$13B!

#C X sign ('no', aka 'break')
#C EastBreak..SouthBreak
x = 13, y = 13, rule = bf
13C$C2A7C2AC$C3A5C3AC$2C3A3C3A2C$3C3AC3A3C$4C5A4C$5C3A5C$4C5A4C$3C3AC
3A3C$2C3A3C3A2C$C3A5C3AC$C2A7C2AC$13C!

#C Digit zero
#C Input0, FreshInput0
x = 9, y = 13, rule = bf
2.5C$.C5AC$C7AC$C2A3C2AC$C2A2C3AC$C2AC4AC$C7AC$C4AC2AC$C3A2C2AC$C2A3C
2AC$C7AC$.C5AC$2.5C!