# RifL

Paradigm(s) imperative Jesse Hamlin-Navias 2023 Cell-based two-dimensional Turing complete Original `.rkt`

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 Symbol Ace 2 3 4 5 6 7 8 9 10 Jack Queen King Joker A or 1 2 3 4 5 6 7 8 9 10 or 0 J Q K R

The four suits are:

 Suit Symbol Spade Club Heart Diamond 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)
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?
>result< F, 0s R Ks > copy result deck onto 0s

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
```