RifL

RifL is a tactile self-modifying imperative esoteric coding language. Tactile means that RifL can be fully represented with real-world objects: RifL is written in playing cards. You can spread cards out on a table and perform RifL code by hand. RifL was developed as an educational tool, to allow students who learn physically to run algorithms by hand.
==History==
RifL was started in 2020 as a project for a college class, with the goal of creating an esoteric language that could be run physically. It was partially finished there, and the first build was completed 3 years later in 2023. The only current interpreter for RifL is built in and for Racket. It was built using beautiful-racket and originally used brag, but latter scrapped brag for a custom built parser.
==Language Overview==
To write and read RifL code, a notation system for cards is needed. All cards have a pip value, followed by a suit letter (except for Jokers which have no suit).
Pip 	Ace 	2	3	4	5	6	7	8	9	10 	Jack	Queen	King	Joker
Symbol	A or 1	2	3	4	5	6	7	8	9	10 or 0	J 	Q 	K 	R
The four suits are:
Suit 	Spade	Club	Heart	Diamond
Symbol	s 	c 	h 	d
Cards in RifL can also be face-up or face-down. Face-down cards are written with a F in front.
 FJc > The face-down Jack of Clubs
 F0d > The face-down Ten of Diamonds
A face-down Joker can be written as FR, or shorthanded as just F.
 FR > A face-down Joker
 F > Also a face-down Joker
===Cards as Data===
RifL code is broken into arguments. An argument is either a series of number cards (from A-10), a single Joker, or a single Royal card. Data is a subset of arguments, either being a series of number cards, or a single Joker. Data interpretation is context dependent, and so is not statically typed. However, data is often interpreted based on an argument's leading suit. The leading suit of an argument is the suit of the top (left most) card of the argument.
RifL represents numbers using the number cards. Aces represent the digit 1, Two cards the digit 2, and so on. However Ten cards represent the digit 0.
 As 2s > 12, the number twelve
 As 2s 3s > 123, the number one-hundred and twenty-three
 9s 10s > 90, the number ninety
When interpreting cards as integers, the argument is read like a number, unless the leading suit is clubs, in which case the number is a negative zero or negative whole number.
When interpreting cards as real numbers, the argument is read like an integer, unless the leading suit is spades or clubs, and the suit of a card in the sequence is diamonds. In that case, the first diamonds card represents the decimal point (and not a digit), and all cards after the first diamonds card are the fractional part of the number. If the leading suit of a real number is clubs, the number is negative. Spades is thought of as the positive number suit and clubs is thought of as the negative number suit.
 3s 0d 1s 4s 1s 5s 9s > 3.14159
 3c 0d 1c 4c 1c 5c 9c > -3.14159
When interpreting cards as a boolean, all card sequences evaluate as true, except for the 10d and R. The 10d, and an argument with only tens cards that has a leading suit of diamonds evaluates as false. R evaluates as null. Since 10d is the only card that results in a false data, diamonds is thought of as the boolean suit.
 0s > true
 0d > false
 R > null
When interpreting cards as a character, the argument is read as a number, and that number is used as an ASCII reference. Arguments are only interpreted as characters if they have a leading suit of heart, so heart is thought of as the character suit.
 6h 5h > 'A'
 Ah 2h 2h > 'z'
Jokers, like the number cards, represent data, but are wild cards, and are not valid in all contexts. Jokers are somewhat comparable to the ’null value found in other programming languages, although that comparison sells short the usefulness of the Joker.
===Decks and Arguments===
RifL code is separated into decks of cards, with the top card written at the left, and the bottom card written on the right. Each deck has a name, written before the cards of the deck, followed by a ":". The name of a deck is a whole positive number and a suit. The cards in a deck’s name must all be of the same suit. Additionally, a deck’s name cannot use leading zeros, with the exception of a name that is a single zero.
 0s: 5s, 10s, 6s > The zero spade deck, with the number 506 in it
 1s: 10s, 6s > The 1 spade deck, with the number 6 in it
 3s 2s: 4s, F, 6s > The 32 spade deck, with the number 4 and then 6 in it
Decks can be broken up into any number of lines, but a new deck must always start on a new line, and a deck’s name, including the colon, must all be on the same line. Anything that follows a ">" is a comment, until either a line break or a "<". Anything between a "(" and a ")" is also a comment.
Decks can have multiple arguments, each separated by face-down cards. Face-down cards work much the same way the spaces between words and numbers work, signifying an end to one piece of information and the beginning of the next. The number of face-down cards between arguments does not matter unless a program uses the Kh. Royal Cards and Jokers are special in regards to spacing. They don’t need face-down cards between them and other arguments. Although face-down cards between Jokers and Royal cards is optional, it is almost always best practice to separate everything out with face-down cards.
Royal cards, that is Jacks, Queens and Kings, are instructions to manipulate information in decks. RifL is written in Postfix-notation, meaning each royal card uses the arguments above it to determine what happens.
===Structure of Code===
The decks are laid on a table, with the following structure:
Each space on the table is a deck name. Spaces on the table are empty by default until a deck is put there. When running RifL code, the pointer determines the current deck. The current deck is the deck which RifL pulls from the top of. The pointer always starts at the 10s deck. If the table starts with an empty 10s deck, the program will immediately terminate because RifL programs end when the current deck is empty.
To resolve instructions, RifL uses a special deck called the stack. RifL proceeds in steps. Each step, RifL looks at the top of the current deck, and if it is not a Royal card, puts that card on top of the stack. If the top card of the current deck is a Royal card, RifL pulls cards from the top of the stack until the royal card has the number of arguments it needs, and then follows that Royal card’s instructions. After following the Royal’s instructions, none of the used arguments nor the Royal card goes on top of the stack.
Some Royal cards can refer not only to decks in the table, but also to the stack. The stack has the name R.
==Instructions==
Royal cards, that is Jacks, Queens and Kings, are instructions to manipulate information in decks. RifL resolves these instructions from the top of a deck to the bottom. Each royal card needs a set number of arguments. Below is an abridged listing of what all the royal cards do. You can find the full documentation here.
 Kings
Card	Form 	Description
Ks 	[Origin], [Destination], [Operation] Ks	Copies or moves argument(s) of deck [Origin] onto the top of deck [Destination], based on the suit and number of [Operation]
Kc 	 	'does nothing'
Kh 	[Deck], Kd 	Flip [Deck] over
Kd 	[Deck], Kd 	Shuffle [Deck]
 Queens
Card	Form 	Description
Qs 	[A], [B], [Operation] Qs 	Compares [A] and [B] based on suit of [Operation], and pushes either [A], [B], Ad, or 10d onto the stack
Qc 	[A], [B], [Operation] Qc 	Pushes onto the stack the result of adding, subtracting, multiplying, dividing, or concatenating [A] and [B], based on the suit of [Operation]
Qh 	[A], [B], [Proposition] Qh	If [Proposition] is true, push [A] on top of the stack, otherwise, push [B] on top of the stack
Qd 	[Sequence], [Modifier] Qd 	Push a transformed [Sequence] onto the stack such that the suit of each card of [Sequence] is the same as the leading suit of [Modifier]
 Jacks
Card	Form 	Description
Js 	[Deck], Js 	Move the pointer to [Deck]
Jc 	[X], [Y], Jc 	Push the name of the deck that is to the right [X] spaces and up [Y] spaces onto the stack (Diamonds wrap around to spades)
Jh 	[Deck], Jh 	Push the number of arguments of [Deck] onto the stack
Jd 	[Deck], [Operation], Jd	Either input or output from [Deck] based on suit of [Operation]. Can input data or cards, and can output data or cards
==Physically Running==
All the same rules of RifL apply when running RifL physically. A good way to run RifL by hand is to draw the table out on a large piece of paper, or take masking tape to mark out the grid of the table, and a sharpie to write the name of each grid space that you delineate on the masking tape. Grid spaces need to be large enough to place decks of cards onto. You’ll need a space to one side of the grid to use as your stack. You will need a bunch of decks of cards. They do not need to have the same backs or even be the same size. Additionally, a token of some sort is useful to mark which grid space the pointer is at. Finally, you will need the list of what each Royal card does.
To begin, set up all the cards in the code in their corresponding deck spaces. Place the token on the 0s deck space. Most RifL programs will need extra sets of cards, so keep a handful of decks ready. When running physically, Face-down cards can be any card, unless the code you are running uses the Kh.
At each step of RifL, take the top card of the deck the pointer is at, and put it on top of the stack. If the top card of the pointer deck is a Royal card, instead look up how many arguments it needs. One by one take cards from the top of the stack, and put them on top of a temporary pile. Do this until you get the required number of arguments for the Royal card, and the top card of the stack is a face-down card, a Joker, or the stack is empty. Then follow the instructions of the Royal card. Once you are done following the instructions, take the Royal card and any cards in that temporary pile and put them in a discard to the side.
If at any time a Royal card requires an argument from the stack, and there are no more arguments in the stack, the code has hit an error and the code stops. If at any time a Royal card makes its way into the stack, the code hits an error and stops.
==Examples==
===Hello, World!===
This program prints out "Hello World!"
 0s: 3h 3h F Ah 10h 10h F Ah 10h 8h F Ah Ah 4h F Ah Ah Ah F 8h 7h F > "!dlroW"
 3h 2h F > space
 Ah Ah Ah F Ah 10h 8h F Ah 10h 8h F Ah 10h Ah F 7h 2h > "olleh"
 F R F Ac Jd > print out the stack
===Truth Machine===
Takes an input. If input starts with 0 or false, print input & terminate. Otherwise print input infinitely.
This program uses the Kh. The bottom three lines of the program are two mutually exclusive functions.
 10s: R F, 10s, F, >Results of if statement
 10d, F, >for concatenation
 2c, F, Ad, Jd >Take data input onto 2c
 2c, F, 10s, F, 10s, Ks >Copy top arg 2c onto 10s
 >10d, F, input,< R, Qc >Concat 10d + input
 >R F, 10s, F, 10d, input,< Qh >If top arg input is not 0, 10s. Else R.
 >R or 10s< Kh > flip either deck 10s or R
 >If below section is flipped, prints out deck 2c and terminates
 10s, FJd, 10s, R, Ks > Copy 10s deck onto 10s deck
 2c, FAc, Ac, Jd > Print out deck 2c
 10s, F2c, 10s, R, Ks > Copy 10s deck onto 10s deck
===Fibonacci===
Takes a positive whole number input, and outputs the nth number of the Fibonacci sequence, where n0 = 0 and n1=1.
 0s: 2c, F Ad, Jd > input data to 2c
 Ah, F, 0s, R Ks > copy Ah onto 0s
 
 Ac: 0s, F, 1s, F > 0th and 1st term of Fib
 
 2c: >input deck
 
 Ah: >(if input less than 2)
 Ad, F, 2d, F, > load if results
 2c, F 0s, R Ks > copy input to 0s
 >input< F 1s, F, As, Qs > greater of input and 1
 >result< F, 1s, F, Ad Qs > is input less than 2?
 >Ad, F, 2d, F, result< Qh >if result, Ad, else 2d
 >result< F, 0s R Ks > copy result deck onto 0s
 
 Ad: >(true case: print result)
 Ac, F, 0s, F, > load for Ks
 2c, F, 0s, R, Ks > copy input to 0s
 >Ac, F, 0s, F, input< Ks > get input arg of Ac onto 0s
 R, Ac, Jd > print out input arg of Ac
 
 2d: Ac, F, 3c, F, 1s Ks > copy 2nd args of Ac onto deck 3c
 Ac, F, 0s, F, 1d Ks > move full 2s onto 0s
 >2s args< F, As, Qc > add args of 2s together
 F, R, Ac F 0h Ks > move result onto Ac
 3c, F, Ac, F, 0h, Ks > move 3s onto 2s
 2c, F, 0s, F, 0h, Ks > move input to 0s
 >input< F, 1s, F Ac Qc > input - 1
 R, 2c, F, 0h, Ks > move result onto 2c
 Ah, F, 0s, R Ks > copy Ah onto 0s
===Quine===
A program that prints out itself.
 10s: 10s FR As R Ks As FR 2s FR 2d Ad Ks As FR 2s R Ks 2s FR As R Ks 3h 2h FR 5h 8h FR Ah Ah 5h FR As 10s FR R Ac Jd As FR As Jd 10s FR As R Ks
Commented version of the quine (not technically a quine, since the comments are not printed out by the program).
 10s: 10s FR As R Ks > copy deck 10s onto deck As
 As FR 2s FR 2d Ad Ks > move the first 22 arguments of deck As onto deck 2s
 As FR 2s R Ks > copy *what remains* of deck As onto deck 2s
 2s FR As R Ks > copy deck 2s onto deck As
 3h 2h FR 5h 8h FR Ah Ah 5h FR As 10s FR > "10s: " reversed
 R Ac Jd > print the stack as data
 As FR As Jd > print deck As as cards
 10s FR As R Ks > this line effectively does nothing,
 > but is the *what remains* of deck As
===99 Bottles of Beer===
This program prints out the 99 bottles of beer song
 0s: 1s, F, 0s, R Ks >copy 1s onto 0s
 
 1s: > if bottles > 2, copy 2s onto 0s, else copy 3s onto 0s
 3s, F, 2s, F > load if results
 0c, F, 0s, R, Ks >copy 0c onto 0s
 >0c< F 2s, F, As, Qs > greater of 0c and 2
 (0c or 1) F, 2s, FR, Ah, Qs > 0c less or equal 2?
 >3s, F, 2s, F< (0c or #f) Qh >if 0c less or equal 2, 3s, else 2s
 (3s or 2s) F, 0s, R, Ks > copy 2s or 3s onto 0s
 
 2s: > print decks in order: 0c Ah 2h 3h 0h 0c Ah 2h 0h 4h 5h 0h
 0c, F, Ac, Jd, Ah, F, Ac, Jd, 2h, F, Ac, Jd,
 3h, F, Ac, Jd, 0h, F, Ac, Jd, 0c, F, Ac, Jd,
 Ah, F, Ac, Jd, 2h, F, Ac, Jd, 0h, F, Ac, Jd,
 4h, F, Ac, Jd, 5h, F, Ac, Jd, 0h, F, Ac, Jd
 > subtract 1 from 0c
 0c, FR, 0s, FR, 0h, Ks > move 0c onto 0s
 >0c< F, 1s, FR, Ac, Qc > subtract 1
 FR, R, FR, 0c, FR, 0h, Ks >move result onto 0c
 > print decks in order: 0c Ah 2h 3h 0h
 0c, F, Ac, Jd, Ah, F, Ac, Jd, 2h, F, Ac, Jd,
 3h, F, Ac, Jd, 0h, F, Ac, Jd
 > copy 1s onto 0s
 1s, F, 0s, R, Ks > copy 1s onto 0s
 
 3s: > print decks in order: 0c 6h 2h 3h 0h 0c 6h 2h 0h 7h 5h 0h 1c 6h 2h 3h 0h
 0c, F, Ac, Jd, 6h, F, Ac, Jd, 2h, F, Ac, Jd,
 3h, F, Ac, Jd, 0h, F, Ac, Jd, 0c, F, Ac, Jd,
 6h, F, Ac, Jd, 2h, F, Ac, Jd, 0h, F, Ac, Jd,
 7h, F, Ac, Jd, 5h, F, Ac, Jd, 0h, F, Ac, Jd,
 1c, F, Ac, Jd, 6h, F, Ac, Jd, 2h, F, Ac, Jd,
 3h, F, Ac, Jd, 0h, F, Ac, Jd
 > print decks in order: 1c 6h 2h 3h 0h 1c 6h 2h 0h 7h 5h 0h 8h Ah 2h 3h
 1c, F, Ac, Jd, 6h, F, Ac, Jd, 2h, F, Ac, Jd,
 3h, F, Ac, Jd, 0h, F, Ac, Jd, 1c, F, Ac, Jd,
 6h, F, Ac, Jd, 2h, F, Ac, Jd, 0h, F, Ac, Jd,
 7h, F, Ac, Jd, 5h, F, Ac, Jd, 0h, F, Ac, Jd,
 8h, F, Ac, Jd, Ah, F, Ac, Jd, 2h, F, Ac, Jd,
 3h, F, Ac, Jd
 > terminate
 
 > Bottle Count
 0c: 9s 9s 
 
 > "1"
 1c: 1s 
 
 >"\n"
 0h: Ah 0h
 
 >" bottles"
 Ah: 3h 2h FR 9h 8h FR Ah Ah Ah FR Ah Ah 6h FR
 Ah Ah 6h FR Ah 0h 8h FR Ah 0h Ah FR Ah Ah 5h FR 
 
 >" of beer"
 2h: 3h 2h FR Ah Ah Ah FR Ah 0h 2h FR 3h 2h FR
 9h 8h FR Ah 0h Ah FR Ah 0h Ah FR Ah Ah 4h FR
 
 >" on the wall"
 3h: 3h 2h FR Ah Ah Ah FR Ah Ah 0h FR 3h 2h FR
 Ah Ah 6h FR Ah 0h 4h FR Ah 0h Ah FR 3h 2h FR
 Ah Ah 9h FR 9h 7h FR Ah 0h 8h FR Ah 0h 8h FR 
 
 >"Take one"
 4h: 8h 4h FR 9h 7h FR Ah 0h 7h FR Ah 0h Ah FR
 3h 2h FR Ah Ah Ah FR Ah Ah 0h FR Ah 0h Ah FR
 
 >" down pass it around"
 5h: 3h 2h FR Ah 0h 0h FR Ah Ah Ah FR Ah Ah 9h FR
 Ah Ah 0h FR 3h 2h FR Ah Ah 2h FR 9h 7h FR
 Ah Ah 5h FR Ah Ah 5h FR 3h 2h FR Ah 0h 5h FR
 Ah Ah 6h FR 3h 2h FR 9h 7h FR Ah Ah 4h FR
 Ah Ah Ah FR Ah Ah 7h FR Ah Ah 0h FR Ah 0h 0h FR 
 
 >" bottle"
 6h: 3h 2h FR 9h 8h FR Ah Ah Ah FR Ah Ah 6h FR
 Ah Ah 6h FR Ah 0h 8h FR Ah 0h Ah FR
 
 >"Take it"
 7h: 8h 4h FR 9h 7h FR Ah 0h 7h FR Ah 0h Ah FR
 3h 2h FR Ah 0h 5h FR Ah Ah 6h FR 
 
 >"No more"
 8h: 7h 8h FR Ah Ah Ah FR 3h 2h FR Ah 10h 9h FR
 Ah Ah Ah FR Ah Ah 4h FR Ah 10h Ah FR
===Brainfuck===
An interpreter for the esoteric language Brainfuck. The program is very long, so a fully commented version is provided here.
 0s : 0c Js 0s 
 As : 0s 
 0c : 4d FR Ad Jd 1c 0c FR 2c FR 4d Jh R 3d FR 0s Ks FR 2d
 FR 0c R Ks FR Ad Qs Qh FR 0c R Ks 
 Ac : 1c 0c FR 2c FR 2d FR 0c FR 0h Ks FR As FR As Qc FR R 2d
 FR 0s Ks FR 3d FR 0c R Ks FR Ad Qs Qh FR 0c R Ks 
 2c : Ac FR 3c FR 4d FR 0c FR 2d FR 0c FR R Ks Ks FR 4h 3h
 FR Ac Qs FR 4h 3h FR Ah Qs FR 4d FR 0c FR 2d FR 0c FR
 R Ks Ks FR 4h 6h FR As Qs FR 4h 6h FR Ah Qs FR Ac Qs Qh FR 0c R Ks 
 3c : 4c FR 5c FR 4d FR 0c FR 2d FR 0c FR R Ks Ks FR 9h 1h FR Ah Qs Qh FR 0c R Ks 
 4c : 2d FR 0c R Ks FR Ah Qd FR R 5d FR 0h Ks Ac FR 0c R Ks 
 5c : 6c FR 7c FR 4d FR 0c FR 2d FR 0c FR R Ks Ks FR 9h 3h FR Ah Qs Qh FR 0c R Ks 
 6c : 6d FR 0c FR 5d Jh FR 0s FR Ad Qs Qh Js FR 5d FR 0c FR
 0s Ks FR Ah Qd R 2d FR 0c R Ks FR Ah Qd FR 0h Ks 2d
 FR 0c R Ks FR Ah Qd R 5d FR 0c FR 0h Ks FR 0h Ks Ac FR 0c R Ks 
 7c : Ac FR 8c FR 4d FR 0c FR 2d FR 0c FR R Ks Ks FR 6h 0h FR Ah Qs Qh FR 0c R Ks 
 8c : Ac FR 9c FR 4d FR 0c FR 2d FR 0c FR R Ks Ks FR 6h 2h FR Ah Qs Qh FR 0c R Ks 
 9c : 4d FR R 2d FR 0c R Ks FR Ah Qd Ks 2d FR 0c FR 0h Ks
 FR As FR Ac Qc FR R 2d FR 0h Ks 3d FR 0c FR 0h Ks FR As
 FR Ac Qc FR R 3d FR 0h Ks Ac FR 0c R Ks 
 1c 0c : 2d FR 0c FR 0h Ks FR Ac FR As Qc R FR 2d FR
 0h Ks 0c FR 6d FR 5d Jh FR 0s FR Ad Qs Qh Js
 2d R 0h Ks Ac R 2d FR 0h Ks 1c 1c FR 0c R Ks 
 1c 1c : 0c FR 1c 2c FR 2d FR 0c FR 0h Ks FR As FR As Qc FR
 R 2d FR 0s Ks FR 3d FR 0c R Ks FR Ad Qs Qh FR 0c R Ks 
 1c 2c : 4d FR 0c FR 2d FR 0c FR R Ks Ks FR Ac Qd FR 0c R Ks 1c 1c FR 0c R Ks 
 4c 3c : 0s FR 0d FR 0c R Ks FR 0c FR 0h Ks FR As FR As Qc FR R 0c FR 0s Ks FR
 2s 5s 6s FR Ad Qs FR Qh R 0d FR 0c R Ks FR 0h Ks 
 4c 1c : 4c 1c FR 4c 1c R Ks 0d FR 4c 1c R Ks R R Ks 5d FR 0d FR 4c 1c R Ks FR
 0h Ks 0c Js 4c 1c FR 4c 1c R Ks 
 4c 2c : 4c 2c FR 4c 2c R Ks 5d R R Ks 5d FR Ad Jd 0c Js 4c 2c FR 4c 2c R Ks 
 4c 4c : 4c 2c FR 0c FR 5d Jh FR 0s FR Ad Qs Qh Js 0c FR 4c 1c FR 5d Jh FR 0s FR Ah Qs Qh Js 
 4c 5c : 2s 5s 5s FR 0d FR 0c R Ks FR 0c FR 0h Ks FR As FR Ac Qc FR R 0c FR 0s Ks FR
 Ac FR Ah Qs FR Qh R 0d FR 0c R Ks FR 0h Ks 
 4c 6c : 0d FR 0c R Ks FR 0c FR 0s Ks FR Ah Qd R 4c 7c FR 0h Ks 4c 7c FR Ac Jd 4c 7c R R Ks 
 6c 0c : 9d FR 0c FR 0d FR 0c FR 0s Ks FR 0s FR Ad Qs Qh Js 0d FR 0c FR 0h Ks FR As FR Ac Qc R 0d FR 0h Ks 
 6c 2c : 0d FR 0c FR 0h Ks FR As FR As Qc R 0d FR 0h Ks 6c 3c FR 6c 4c FR 0d
 FR 0c FR R Ks FR 1d FR 0c FR R Ks FR Ad Qs Qh FR 0c R Ks 
 6c 3c : 1d FR 0c FR 0h Ks FR As FR As Qc R 1d FR 0h Ks 0s R 1d FR 0c R Ks FR 0h Ks 
 9c 1c : 9c 2c FR 9c 0c FR 0d FR 0c R Ks FR 0c R Ks FR 0s FR Ad Qs Qh FR 0c R Ks 
 9c 2c : 2d FR 0c FR 0h Ks FR Ah Qd FR 0c R Ks R 2d FR 0h Ks 
 9c 3c : 9c 5c FR 9c 4c FR 0d FR 0c R Ks FR 0c R Ks FR 0s FR Ad Qs Qh FR 0c R Ks 
 9c 4c : 2d FR 0c FR 0h Ks FR Ah Qd FR 0c R Ks R 2d FR 0h Ks 
 0d : 0s 
 1d : As 
 2d : 0s 
 6d : 7d FR Ac Jd 4d FR 6d FR 2d FR 6d FR 0s Ks Ks FR R FR Ac Jd FR 8d FR Ac Jd 2d FR Ac Jd 
 7d : 7h 2h FR 9h 7h FR Ah Ah 10h FR Ah 10h 3h FR Ah 10h 5h FR Ah Ah 10h FR Ah 10h 3h FR 3h 2h FR 3h 4h FR 
 8d : 3h 4h FR 3h 2h FR 9h 7h FR Ah Ah 6h FR 3h 2h FR Ah 10h 5h FR Ah Ah 10h FR
 Ah 10h 10h FR Ah 10h Ah FR Ah 2h 10h FR 3h 2h FR 
 9d : Ad 0d FR Ac Jd 2d FR Ac Jd 
 Ad 0d : 6h 7h FR Ah 10h Ah FR Ah 10h 8h FR Ah 10h 8h FR 3h 2h FR Ah Ah 7h FR
 Ah Ah 10h FR Ah 10h 10h FR Ah 10h Ah FR Ah Ah 4h FR Ah 10h 2h FR
 Ah 10h 8h FR Ah Ah Ah FR Ah Ah 9h FR 3h 2h FR 9h 7h FR Ah Ah 6h FR
 3h 2h FR Ah 10h 5h FR Ah Ah 10h FR Ah 10h 10h FR Ah 10h Ah FR Ah 2h 10h FR 3h 2h FR
==External Resources==
Download RifL language for Dr.Racket
Documentation
Category:Languages
Category:Low-level
Category:Imperative paradigm
Category:2023
Category:Cell-based
Category:Stack-based
Category:Turing complete
Category:Two-dimensional languages
Category:Implemented
Category:Non-textual
Category:Low-level
Category:Self-modifying