<!--Please note that this specification is written in PLAIN TEXT as per the Esolang Buffet rules-->

# Rabbitsfoot
> “I think that someone will remember us in another time.”
> — Sappho of Lesbos (Lobel & Page, Fragment 147)

The Rabbitsfoot language employs the revolutionary new "rabbitsfoot" paradigm, which some liken to the sweet-spot between blockchain, quantum computing, and big data. It also employs the imperative paradigm, which is counter-revolutionary and old.

It was designed by IFcoltransG in 2022 for the first inaugural Esolangs Buffet event on the Unofficial Esolangs Discord Server. (The first inaugural one, not for any other inaugural ones after that.)

Rabbitsfoot's file extension is `.rtf` for programs, or `.rtfm` for Rabbitsfoot library modules.

## Usage
Run the interpreter on your program from the command line.
```sh
# regular mode
python ./rabbitsfoot.py FILENAME
# verbose mode:
python ./rabbitsfoot.py -v FILENAME
python ./rabbitsfoot.py --verbose FILENAME
```

The interpreter will read from standard input a list of integers.
The integers are separated by whitespace and/or commas, and can have optional `[` and `]` on each end. The list is terminated by a newline.

Output is written like a Python list.

### Example inputs
`1 2 3 4 5`
`[1, 2, 3, 4, 5]`

### Example program
```rabbitsfoot
# cat
,
.
```

### Example output for example inputs into example program
`[1, 2, 3, 4, 5]`

## Execution
The interpreter stores a tuple of W indices called the index tuple, where W is the window size.
The interpreter stores an array of size N called the array, where N is the number of integers in the program input.
The interpreter stores a stack, called the stack.
The interpreter optionally stores a single value, called the cache.

Initially, the array is set to the program input.
Initially, the index tuple is set to (0, ..., 0).
Initially, the stack is empty.

If N is ever 0, the program terminates immediately and outputs its results.

### Input
Whenever input is requested, a list V of size W is pushed onto the stack. The i-th element of V is taken from the array at index j, where j is the i-th element of the index tuple.

For instance, if W=N and the index tuple is (0, 1, ..., N-1), then V has the exact same elements as the array. If W=2, N>0 and the index tuple is (0, 0), then V will be [X, X], where X is the first element of the array.

After the array is initialised, the program input itself is treated as compromised and must no longer be trusted. Subsequent requests for input will treat the array as the only source of truth.

### Basic Loop
The user's program is run, line by line, from the first line, until any control flow statements are reached.

### Stack
The stack can contain integers, lists of integers or strings. However, the stack cannot contain its excitement whenever it sees a bunny rabbit.

If a value is popped from an empty stack, that is undefined behaviour. So don't pop from an empty stack.

### Window size
W is equal to 1 if the program contains no `[`...`]` instructions. Otherwise, it is inferred so that it fits with a `[`...`]` instruction.

## Instructions
All lines must exactly comport to one or more of the following standards.
Except where otherwise noted, commands must take up between 0 and 2 lines (exclusive) with only whitespace left over.

Punctuation that corresponds with endorsed operations have a newline automatically inserted after them, unless they are part of a comment.

### Comments
Any line containing only whitespace is ignored.
Any line beginning with `#` or `REM ` is ignored.
It's nothing personal, and the interpreter ignoring your code doesn't reflect on your value as a person.

### Loop
The `.` command pops a list from top-of-stack, then iterates through each index i in it, storing the i-th value of the list into the array index given by the i-th element of the index tuple. If the value at top-of-stack is not a list, that is undefined behaviour.

(If it helps, imagine the list is a list of rabbits. Then the `.` command pops the list off the stack, and lets all of the rabbits loose, so that they find the value in the index tuple that was at the same position as them, and gnaw at the index in the array given by the value they found, until that array location becomes the value corresponding to that rabbit.)

Then the interpreter increments that the index tuple and then jumps to the start of the program. (Implementations must preserve the stack.)

All programs must contain at least one `.`. Programs that contain only comments are undefined behaviour.

To increment the index tuple, add one to its rightmost value.
Then until no elements of the tuple equal N, pick any element that equals N, set it to exactly 0, then add one to the element to its left in the tuple. If no such element exists, the program terminates immediately and outputs its results.

### Literal
The `[`...`]` command pushes a given list of integers onto the stack. Between the `[` and the `]` are a sequence with length W of whitespace separated integers.

Patent pending.

### Zilch
The `0` command pushes a 0 to the stack.

If both N and W equal 0, or if the index tuple is (0, ..., 0), then it is undefined behaviour to run `0`. That would be too many zeros. It's safer this way.

### Memory
The first time `|` is executed, it peeks at the top value of the stack and saves it to the cache. Any subsequent time it is run, it pops the top-of-stack and pushes a copy of the value saved in the cache.

It is undefined behaviour for `|` to be executed when the stack is empty.

### Addition
The `+` command pops two integers or two lists of integers from the stack, adds them (elementwise in the case of two lists), then pushes the result.

Implementations are free to add the values in any order they choose. However, they should be forewarned that addition is commutative, meaning the implementator's choice is just as meaningless as every other choice they make in their lives.

### Reverse Factorisation
The `*` pops integers or two lists of integers from the stack, and pushes their product or elementwise product, respectively.

Again, implementations may left-multiply or right-multiply. It's their prerogative. Commutativity of multiplication is left as an exercise to the reader.

### Bounce
When the `!` command is run, if the value at top-of-stack is an integer, the interpreter jumps to the next `!`. Otherwise, if the value at top-of-stack is a list or a string, the command is treated as a no-op. It is undefined behaviour for a program to have an odd number of `!`.

The value at top-of-stack is not popped. It is undefined behaviour to run `!` if the stack is empty, or for the interpreter to try to jump to the next `!` when there are not more left.

### Compare
The `-` command pops two integers from the stack and pushes the max of the two integes, then pushes the negative of the min of the two integers. If the first value popped is a list rather than an integer, no second value is popped. Instead, every integer in the list is replaced with 1, 0 or -1 corresponding to if it is positive, zero, or negative, respectively, then the resulting list is pushed again.

Maximum picks closest to ∞ and minimum picks closest to 0.

### Factorial
The `?` command performs a factorial operation on the integer at top-of-stack. If you are wondering why the symbol isn't `!`, it's because that symbol was taken.

It is undefined behaviour for `?` to be run on a string or list, or for the integer to be negative.

### Pack
The `$` command checks if there are exactly W integers on the stack. If so, it pops those integers and pushes a list containing them. If not, that is undefined behaviour.

You can imagine it like having a stack filled with rabbits at nighttime, then when day breaks the rabbits go back to the warren (as long as there are exactly the right amount of rabbits) and the warren is pushed to the stack. It's like that.

### Division
The `/` command elementwise divides the list at top-of-stack by W, rounding down.

If the value at top-of-stack is a string or an integer rather than a list of integers, that is undefined behaviour.

### Input Request
To request input data to process, the programmer needs only leave a line with a lone `,` in it, which strikes me as awfully convenient. Don't you think?

### Eval
The `^` command pops a string from the stack, splits it by newlines, then runs each line of code sequentially. It is illegal for the string to contain a `.` instruction (though it may contain further `^` instructions).

Trying to execute an integer or a list is undefined behaviour.

Imagine that your string is actually a rabbit. Then running `^` causes that rabbit to be popped from the stack and executed. Poor rabbit.

### Exec
The `@` command executes the commands from the first line of the source code. Note that many instructions may be executed in this way if they didn't have newlines following them pre-endorsement.

It is undefined behaviour for `@` to be placed on the first line of the source code.

### Transmogrification
The `~` command pops W lists from the stack and assembles a 2-d grid of integers, where if an integer is at position x of the y-th popped list, it is put at position (x, y-1). Then for each x coordinate χ starting from 0, the interpreter pushes a list of every integer on a grid point that satisfies x=χ, starting from y=0.

It may help understanding if you imagine that there are rabbits arranged in a little grid. (The rabbits are the contents of the popped lists.) Then the rabbits do a dance, and end up in the positions described above. Then the lines of rabbits are pushed onto the stack.

If any value pushed is not a list of integers, that is undefined behaviour.

### Random
The `%` command pops an integer or a list. If an integer is popped, a uniform random integer between 0 and that integer (inclusive) is pushed. If a list is popped, it is pushed shuffled.

Should a negative integer be popped this way, the behaviour is undefined.

### Increment
The `<`...`>` command increments a series of indices. Between the `<` and `>` are a sequence of whitespace-separated non-negative integers. For each number from left to right, the corresponding array element at that index is increased by 1.

### Semantic comments
The `=` command is a little like a macro. It inserts the text of the first comment in the source code into the program at the position of the `=`, uncommented.

It is undefined behaviour for `=` to come before the first comment in the program.

Fun animal fact: the `=` sign looks like two rabbit ears!

## Endorsements and Awards
The following instructions are certified and endorsed by the Rabbitsfoot Lucky-Paw Seal of Approval (RLPoA):
### Arithmetic operators
These symbols deserve respect for their longstanding contribution to the buttons on calculators.
- `+`
- `*`
- `/`
### Other brainfuck symbols
These symbols have contributed meaningfully to the history of esolangs.
- `,`
- `.`
- `[`...`]`
- `<`...`>`
### Who knows really
These symbols are financial benefactors of the Rabbitsfoot programming language.
- `~`
- `|`
- `!`
- `?`

The symbol `-` has received an *honorary* endorsement in appreciation of its substantial contributions to `[`...`]` and to arithmetic. Due to a technicality, `-` alas cannot receive implicit newline privileges, but was awarded a small cash koha instead.

## Rabbitsfoot library modules
Files with the `.rtfm` extension are treated as Rabbitsfoot library modules rather than programs. Rabbitsfoot library modules are executed as if they were programs.

import pathlib
import itertools
import sys

def cmp(a, b):
    # taken from https://docs.python.org/3.0/whatsnew/3.0.html#ordering-comparisons
    return (a > b) - (a < b)

def flip(x):
    # transposes
    return [list(row) for row in zip(*x, strict=True)]

def factorial(n):
    for i in range(1, n):
        n *= i
    return max(n, 1)

def is_comment(line):
    return line.startswith("#") or line.startswith("REM ")

# read command line arguments
if len(sys.argv) < 2:
    print("Please pass filename of code", file=sys.stderr)
    sys.exit(1)
verbose_mode = "-v" in sys.argv or "--verbose" in sys.argv
filename = sys.argv[-1]
code = pathlib.Path(filename).read_text()

if verbose_mode:
    # enable logging to stderr
    log = lambda *a, **k: print(*a, **k, file=sys.stderr)
else:
    # disable logging
    log = lambda *a, **k: None

# read list of integers from stdin
data = [
    int(num)
    for num
    in input()
        .replace(",", " ")
        .strip("[ ]").split()
]

if not code.split("\n"):
    raise SyntaxError("Code has no lines")

# preprocessing
# replace all @ macros with the first line of the program
first_line = code.split("\n")[0]
if "@" in first_line:
    raise SyntaxError("`@` on first line of program")
code = code.replace("@", first_line)
# find first comment for the = command
for line in code.split("\n"):
    if is_comment(line):
        first_comment = line.lstrip("REM ").lstrip("#")
        break
    if "=" in line:
        raise SyntaxError("`=` before first comment")
else:
    first_comment = ""
# remove comments
code = "\n".join(
    line
    for line
    in code.split("\n")
    if not is_comment(line)
)
# insert macros from first comment
if "=" in code:
    code = code.replace("=", first_comment)
# insert newlines after endorsed commands
endorsed = {"+", "*", "/", "~", "|", ",", ".","]", ">", "!", "?"}
for endorsement in endorsed:
    # insert newlines automatically
    code = code.replace(endorsement, endorsement + "\n")

# get window size
window_size = 1
for line in code.split("\n"):
    if line.startswith("[") and line.endswith("]"):
        # found a [...] line
        # so can infer size of window
        window_size = len(line.strip("[ ]").split())
        break
# otherwise default to 1
log(f"{window_size = }")

stack = []
cache = None

ranges = [range(len(data)) for _ in range(window_size)]
for indices in itertools.product(*ranges):
    log(f"Iterating with {indices = }")
    for line in code.split("\n"):
        line = line.strip()
        log(f"  Runnning line: {line}")
        match line:
          case ",":
            # get input from array
            stack.append([data[i] for i in indices])
          case "*":
              # multiply
              top = stack.pop()
              second = stack.pop()
              match (top, second):
                case (int(), int()):
                    stack.append(top * second)
                case (list(), list()):
                    product = [x*y for x,y in zip(top, second, strict=True)]
                    stack.append(product)
                case _:
                    raise TypeError("Mixed-type multiplication is not supported")
          case "+":
              # add
              top = stack.pop()
              second = stack.pop()
              match (top, second):
                case (int(), int()):
                    stack.append(top + second)
                case (list(), list()):
                    summation = [x+y for x,y in zip(top, second, strict=True)]
                    stack.append(summation)
                case _:
                    raise TypeError("Mixed-type addition is not supported")
          case "?":
              # factorial
              top = stack.pop()
              if isinstance(top, int):
                  if top < 0:
                      raise ValueError("Attempted factorial on negative number")
                  product = factorial(top)
                  stack.append(product)
              else:
                  raise TypeError("Factorial on something other than an integer")
          case "-":
              # get max/min of two ints or elementwise get sign
              top = stack.pop()
              if isinstance(top, int):
                  second = stack.pop()
                  stack.append(max(top, second))
                  stack.append(-min(top, second), key=abs)
              else:
                  sign = [cmp(x, 0) for x in top]
                  stack.append(sign)
          case "|":
              # save/load memory
              if cache is None:
                  cache = stack[-1]
                  log(f" -cache set to {cache}")
              else:
                  stack.pop()
                  stack.append(cache)
          case "~":
              # flip about main diagonal
              rows = [stack.pop() for col in range(window_size)]
              cols = flip(rows)
              cols.reverse()
              stack.extend(cols)
          case "0":
              # push 0
              if indices == (0,) * window_size:
                  raise ValueError("Tried to execute `0` when index tuple was all zeros")
              elif len(data) == 0 and window_size == 0:
                  raise ValueError("Tried to execute `0` when window size and input size were both 0. Very dangerous!")
              else:
                  stack.append(0)
          case "$":
              # pack integers into list and push
              integers = []
              while stack:
                  next_integer = stack.pop()
                  if not isinstance(next_integer, int):
                      raise TypeError("Tried to pack non-integer into list of integers")
                  integers.append(next_integer)
              if len(integers) != window_size:
                  raise ValueError("Wrong number of popped integers")
              stack.append(integers)
          case "!":
              # conditional jump
              basic_count = code.replace(" ", "").replace("\t", "").count("\n!\n")
              if code.startswith("!") != code.endswith("!"):
                  basic_count += 1
              if basic_count % 2 == 1:
                  raise SyntaxError("Odd number of `!`")
              if isinstance(stack[-1], int):
                  # this code path shouldn't happen
                  raise NotImplementedError()
          case "^":
              # eval
              eval_code = stack.pop()
              if isinstance(code, str):
                  for eval_line in eval_code.split("\n"):
                      if eval_line == "":
                          continue
                      if eval_line.strip() == ".":
                          raise ValueError("Tried to execute a `.` within a `^` evaluation")
                      # this code path shouldn't happen
                      raise NotImplementedError()
              else:
                  raise TypeError("Tried to execute something other than a string")
          case "/":
              # divide
              top = stack.pop()
              quotient = [num // window_size for num in top]
              stack.append(quotient)
          case "%":
              # randomise
              top = stack.pop()
              match top:
                case int():
                    if top < 0:
                        raise ValueError("Random integer from empty set")
                    stack.append(random.randrange(0, top + 1))
                case list():
                    top = list(top)
                    random.shuffle(top)
                    stack.append(top)
          case x if x.startswith("[") and x.endswith("]"):
              # push literal
              values = [
                  int(num)
                  for num
                  in x.strip("[ ]").split()
              ]
              if len(values) != window_size:
                  raise SyntaxError("Literal does not match window size")
              stack.append(values)
          case x if x.startswith("<") and x.endswith(">"):
              # increment indices of array
              if "-" in x:
                  raise ValueError("Negative integer in indices to increment")
              values = [int(num) for num in x.strip("< >").split()]
              for index in values:
                  data[index] += 1
          case ".":
              # end program
              break
          #case ":":
          #    # deprecated duplicate
          #    top = stack.pop()
          #    stack.append(top)
          #    stack.append(top)
          #case ";":
          #    # deprecated swap
          #    top = stack.pop()
          #    second = stack.pop()
          #    stack.append(top)
          #    stack.append(second)
          case "":
              # empty line
              continue
          case _:
              raise SyntaxError(f"Got malformed line: {line}")
        log(f"  {stack = } <-TOS")
    else:
        # program didn't end with "."
        raise SyntaxError("Program does not contain a `.` instruction")
    # this iteration, we replace all chosen values
    # with new values calculated by the program
    new_values = stack.pop()
    log(f"Replacing values at indices {indices} with {new_values}")
    for index, value in zip(indices, new_values, strict=True):
        data[index] = value
    log(f"{cache = }")
    log(f"{data = }")
    log()

print(data)
log()
log("---")
log("Program terminated successfully.")

from sys import argv

'''
list -> quotation
int -> number
str -> operator
'''


# Will break on 999-deep nested quotations, but I think that's reasonable.
def parse_program(p: str, i: int = 0) -> (list, int):
    program = []
    while i < len(p) and p[i] != ']':
        if p[i] in '~!+':
            program.append(p[i])
        elif p[i] == '[':
            start = i
            quote, i = parse_program(p, i + 1)
            if i >= len(p) or p[i] != ']':
                raise Exception(f'Unclosed quotation at {start}')
            program.append(quote)
        i += 1
    return program, i

def parse_input():
    return [int(s) for s in input().split()]


# When popping two items 'a' will be the leftmost value, 'b' the rightmost.
def reduce(p, dat):
    ret = [p]
    ip = [0]
    while ret:
        if ip[-1] >= len(ret[-1]):
            ret.pop()
            ip.pop()
        else:
##            print(ret, ip, dat, sep='\n')
##            print()
            com = ret[-1][ip[-1]]
            ip[-1] += 1
            match com:
                case int() as i:
                    dat.append(i)
                case list() as q:
                    dat.append(q)
                case '~':
                    if len(dat) > 1:
                        match dat.pop(), dat.pop():
                            case int(a), int(b):
                                if a < b:
                                    dat.append(a)
                                    dat.append(b)
                                else:
                                    dat.append(b)
                                    dat.append(a)
                            case a, b:
                                dat.append(a)
                                dat.append(b)
                case '!':
                    if len(dat) < 2 or not isinstance(dat[-1], list):
                        dat = []
                    else:
                        a, b = dat.pop(), dat.pop()
                        ret.append(a)
                        ip.append(0)
                case '+':
                    if len(dat) < 2 or not isinstance(dat[-1], list):
                        dat = []
                    else:
                        a, b = dat.pop(), dat.pop()
                        dat.append([b] + a)
                        dat.append(a + [b])
                case _:
                    raise Exception(f'Unexpected item in the program: {com}')
    ans = []
    for i in reversed(dat):
        if isinstance(i, int):
            ans.append(i)
        else:
            break
##    print(ans)
##    print(dat)
    return list(reversed(ans))


if __name__ == '__main__':
    if len(argv) != 2:
        raise Exception(f'Wrong number of arguments: {len(argv) - 1}')
    with open(argv[1], 'r') as f:
        program, _ = parse_program(f.read())
    out = reduce(program, parse_input())
    for i in out:
        print(i, end=' ')
    print()
                

# Stack sorter

Stack sorter is a concatenative language based on the concatenative calculus.
It operates via the means of expression rewriting.
Expressions may consist of:
    - operators
    - quotations
    - numbers (only during runtime, not representable in code)


### Operation

The program is parsed into an expression according to the rules explained
below. Input is parsed as a string of whitespace-separated decimal numbers
ending in a newline and prepended to the expression. Any parsing errors may
produce undefined behavior.

The expression is scanned for patterns related to words. The right-most
match is replaced with another expression according to the rule for that
pattern. This match-replace cycle is repeated until there are no matches.

Trailing numbers in the resulting expression are the output of the program.
Only numbers that are outside quotations count for output.


### Operators and patterns

IMPORTANT: patterns don't match within quotations.

There are several words that can be used in the stack sorter, every one
coming with a pattern and a substitution rule. In the examples letters
`X` and `Y` represent arbitrary quotations or numbers, letters `N` and `M`
represents numbers and letter `A` represents an arbitrary expression.
Spaces represent any non-zero number of whitespace delimiters.

    - `NM~`   -> `NM`      if N <= M, else `MN`
    - `XY~`   -> `YX`      if X or Y is not a number, else the rule above matches.
    - `X~`    -> `X`      if previous two rules didn't match.
    - `X[A]+` -> `[XA][AX]`
    - `X[A]!` -> `A`

Any characters except `[]~!+` in the program are discarded.


### Quotations

In code quotations are represented as expressions in brackets: `[]`.
Quotations can be manipulated using operators. Patterns don't match
inside quotations, and numbers contained within them don't count as
trailing numbers.

If brackets in the program don't match it's a parsing error which
produces undefined behavior.


### Examples

Program `[]![]+~!` with input `1 2` will output `1`.

I'm too lazy to write more.


### Interpreter

Interpreter expects one parameter: a file with the program. It will parse the program,
parse one line of input and print out the output if no errors occur.

# Three Stack Bit Math
This esolang has three stacks; A, B and X. The first two, A and B, are used for data storage. A will automatically contain any command line arguments after the program name. X is used for calculations. 

The main logic will be performed using bit magic as comparison operators don't exist. Blocks can be used for limited conditional logic. I haven't confirmed, but it seems to me like this esolang isn't turing complete.

## Blocks
Blocks are the main conditional element in the language. The work by infinetly looping until a stack access is attempted on an empty stack. 

## Instructions
### Block
 * `{`: Opens a block
 * `}`: Closes a block

### Constants
 * `0`: Loads the constant 0 to the X 
 * `1`: Loads the constant 1 to the X 

### Move
 * `a`: Moves one value from A to X
 * `b`: Moves one value from B to X
 * `c`: Moves one value from X to A
 * `d`: Moves one value from X to B
 * `e`: Copies all values from B to A
 * `f`: Copies all values from A to B
 * `g`: Reverses A
 * `h`: Reverses B

### Misc
 * `!`: Pops one value from X
 * `%`: Swaps the top two values of X
 * `.`: Pops and prints the top value of X
 * `$`: Dupelicates the top value of X

### Math and Bit Magic
 * `+`: Adds together the top two values of X
 * `&`: Performs a bitwise AND operation on the top two values of X
 * `|`: Performs a bitwise OR operation on the top two values of X
 * `^`: Performs a bitwise XOR operation on the top two values of X
 * `-`: Performs a bitwise NOT operation on the top value of X
 * `<`: Performs a bitshift left on the top two values of X
 * `>`: Performs a bitshift right on the top two values of X

### Debug
 * `@`: Forces the program to exit
 * `=`: Dumps the stacks' contents

## Usage
Run the interpretter using python 3.10 or newer with the program as the first argument and the data as the rest

import sys

INSTRUCTIONS = list("abcdefgh01!%.+&|^-<>$=@")

Program = list[str | type("Program")]
Stacks = tuple[list[int], list[int], list[int]]

class ExecutionError(RuntimeError):
    pass

def main():
    filename, *data = sys.argv[1:]
    try:
        with open(filename, "r") as file:
            program = compile(file.read())
        run(program, [int(value) for value in data])
    except ExecutionError as e:
        print("Error while executing:", e)
        sys.exit(2)

def compile(program: str) -> Program: 
    stack: list[Program] = [[]]

    for char in program:
        if char in INSTRUCTIONS:
            stack[-1].append(char)
        elif char == "{":
            stack.append([])
        elif char == "}":
            stack[-2].append(stack.pop())
    if len(stack) > 1:
        raise ExecutionError("Not all blocks closed!")
    return stack[0]
    
def run(program: Program, data: list[int]):
    run_block((data, [], []), program, main=True)
    
def run_block(stacks: Stacks, block: Program, main: bool = False):
    a, b, x = stacks
    index: int = 0
    max_index = len(block) - 1
    try:
        while True:
            #print("Executing:", block[index], stacks)
            match block[index]:
                case "a":
                    x.append(a.pop())
                case "b":
                    x.append(b.pop())
                case "c":
                    a.append(x.pop())
                case "d":
                    b.append(x.pop())
                case "e": # Copy content only, no changing references
                    a[:] = b[:]
                case "f": # Copy content only, no changing references
                    b[:] = a[:]
                case "g":
                    a.reverse()
                case "h":
                    b.reverse()
                case "0":
                    x.append(0)
                case "1":
                    x.append(1)
                case "!":
                    x.pop()
                case "%":
                    x += (x.pop(), x.pop())
                case ".":
                    print(x.pop())
                case [*content]:
                    run_block(stacks, content)
                case "+":
                    x.append(x.pop() + x.pop())
                case "&":
                    x.append(x.pop() & x.pop())
                case "|":
                    x.append(x.pop() | x.pop())
                case "^":
                    x.append(x.pop() ^ x.pop())
                case "-": # Bitwise not, not mathematical negation
                    x.append(~x.pop())
                case ">": # Because of the stack, the order is reversed. For these operations order matters
                    second, first = x.pop(), x.pop()
                    x.append(first >> second)
                case "<":
                    second, first = x.pop(), x.pop()
                    x.append(first << second)
                case "$":
                    x.append(x[-1])
                case "=":
                    print("Stacks:", *stacks)
                case "@":
                    raise ExecutionError("Debug exit")

            if index >= max_index:
                if main: 
                    return
                index = 0
            else:
                index += 1
    except IndexError as e:
        if main:
            raise ExecutionError("Index out of bounds in main body!") from e

if __name__ == "__main__":
    main()

The integers are passed as arguments to the interpreter, placing them on the A stack. The integers are printed using the `.` operator in sorted order.

gcc -o interpreter interpreter.c

#!/usr/bin/python3

# // Code by SoundOfSpouting#6980 (UID: 151149148639330304)
# Supplementary program for interpreter, compiles ordered pairs (a, b)(c, d) or list [1, 2, 3, 4] into raw bytes
# Usage: ./compiler.py [input file] [output file]

import sys;import re;open(sys.argv[2],"wb").write(bytes(map(int,re.sub("[^0123456789\s]","",re.sub("[\[\]{}(),]", " ", open(sys.argv[1],"r").read())).split())))

// Code by SoundOfSpouting#6980 (UID: 151149148639330304)
// Usage: interpreter.exe [input file] [program file]

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

const int debug = 0;

int randInt (int m, int M) {
	return 4; // stub
}
void doBetter () {
	puts ("Please Just Do Better");
	exit (randInt (1, 69420));
}

void printList (int* list, int length) {
	printf ("[");
	for (int i = 0; i < length - 1; i++) printf("%d, ", list[i]);
	if (length < 1) puts ("]");
	else printf ("%d]\n", list[length - 1]);
}
void printDisks (int** disks, int* tops, int pegs) {
	puts ("{");
	for (int i = 0; i < pegs; i++) {
		printf ("    %d ", i);
		printList (disks[i], tops[i] + 1);
	}
	puts ("}");
}

int listToDisks (const int* list, const int length, int*** _disks, int** _tops) {
	int pegs = 2;
	for (int i = 0; i < length - 1; i++) if (list[i] > list[i + 1]) pegs++;

	int** disks = (int**) malloc (pegs * sizeof (int*));
	int* tops = (int*) malloc (pegs * sizeof (int));
	for (int i = 0; i < pegs; i++) {
		tops[i] = -1;

		disks[i] = (int*) malloc (length * sizeof (int));
		for (int j = 0; j < length; j++) disks[i][j] = -1; // Not necessary
	}

	int i = pegs - 2, j = 0;
	for (int k = length - 1; k > 0; k--) {
		disks[i][j] = list[k];
		if (list[k-1] > list[k]) {
			tops[i] = j;
			i--;
			j = 0;
		} else j++;
	}
	disks[i][j] = list[0];
	tops[i] = j;

	*_disks = disks;
	*_tops = tops;
	return pegs;
}
void disksToList (int* list, int** disks, const int* tops, const int pegs) {	
	for (int j = 0; j < pegs; j++) for (int k = tops[j]; k >= 0; k--) (list++)[0] = disks[j][k];
}
int move (int** disks, int* tops, const int pegs, const int length, int i, int j) {
	i = i % pegs;
	j = j % pegs;

	if (i == j || tops[i] < 0 || tops[j] > length - 2 || tops[j] > -1 && (disks[i][tops[i]] > disks[j][tops[j]])) return 0;

	tops[j]++;
	disks[j][tops[j]] = disks[i][tops[i]];
	disks[i][tops[i]] = -1; // Not necessary
	tops[i]--;

	return 1;
}

int loadBytes (char* file, int** _list) {
	FILE* fp = fopen (file, "rb");
	if (fp == NULL) doBetter ();

	fseek (fp, 0, SEEK_END);
	const int length = ftell (fp);
	fseek (fp, 0, SEEK_SET);

	int* list = (int*) malloc (length * sizeof (int));
	for (int i = 0; i < length; i++) list[i] = fgetc (fp);
	fclose (fp);

	*_list = list;
	return length;
}

void execute (int* list, int length, int* program, int programLength) {
	if (debug > 5) printList (list, length);

	int** disks;
	int* tops;
	const int pegs = listToDisks (list, length, &disks, &tops);

	if (debug > 6) printDisks(disks, tops, pegs);

	for (int i = 0; i < programLength - 1; i += 2) {
		int s = move (disks, tops, pegs, length, program[i], program[i+1]);
		if (debug > 7) {
			printf ("(%d, %d)%s\n", program[i], program[i+1], s ? "" : " invalid");
			if (s) printDisks (disks, tops, pegs);
		}
	}

	disksToList (list, disks, tops, pegs);

	for (int i = 0; i < pegs; i++) free (disks[i]);
	free (disks);
	free (tops);
}
int isSorted (int* list, int length) {
	int sorted = 1;
	for (int i = 0; i < length - 1; i++) if (list[i] > list[i+1]) {
		sorted = 0;
		break;
	}
	return sorted;
}
void sort (int* list, int length) {
	for (int i = 0; i < length; i++) for (int j = 0; j < length; j++) if (list[i] < list[j]) {
		int x = list[i];
		list[i] = list[j];
		list[j] = x;
	}
}

int* tests[] = {
	(int[]) {},
	(int[]) {172},
	(int[]) {203, 35},
	(int[]) {18, 13, 94},
	(int[]) {193, 46, 26, 129},
	(int[]) {77, 108, 182, 111, 242},
	(int[]) {88, 159, 106, 233, 87, 30},
	(int[]) {151, 106, 165, 236, 180, 249, 113},
	(int[]) {117, 238, 17, 93, 165, 76, 166, 15},
	(int[]) {115, 7, 181, 141, 13, 205, 86, 231, 135},
	(int[]) {118, 23, 77, 47, 177, 48, 15, 111, 25, 75},
	(int[]) {106, 220, 114, 44, 57, 117, 169, 56, 198, 109, 165},
	(int[]) {30, 15, 164, 86, 18, 200, 93, 145, 224, 249, 134, 160},
	(int[]) {167, 230, 10, 83, 226, 93, 97, 218, 98, 51, 115, 236, 94},
	(int[]) {248, 106, 26, 120, 32, 72, 218, 78, 178, 37, 76, 15, 137, 218},
	(int[]) {214, 158, 209, 243, 75, 148, 216, 195, 223, 137, 169, 90, 142, 109, 1}
};
void TRAILS (int* list, int length, int** subprograms, int* subprogramsLengthJ, int subprogramsLengthI) {
	const int requiredComplete = 3;

	int** cases[] = {
		(int*[]) { (int[]) {2,3,0,1}, (int[]) {1,3,0,2}, (int[]) {1,2,0,3}, (int[]) {0,3,1,2}, (int[]) {0,2,1,3} },
		(int*[]) { (int[]) {0,0,1,0,0}, (int[]) {0,1,0,1,0}, (int[]) {0,1,1,1,0}, (int[]) {0,1,2,1,0}, (int[]) {0,2,1,2,0}, (int[]) {1,0,0,0,1}, (int[]) {1,0,1,0,1}, (int[]) {1,0,2,0,1}, (int[]) {1,1,0,1,1}, (int[]) {1,2,0,2,1}, (int[]) {2,0,1,0,2}, (int[]) {2,1,0,1,2} },
		(int*[]) { (int[]) {} }
	};
	int* casesLengthK[] = {
		(int[]) {4,4,4,4,4}, (int[]) {5,5,5,5,5,5,5,5,5,5,5,5}, (int[]) {0}
	};
	int casesLengthJ[] = {5,12,1};
	int casesLengthI = 3;

	int randCase = randInt (0, 14);
	cases[2][0] = tests[randCase];
	casesLengthK[2][0] = randCase;
	
	int complete = 0;
	for (int i = 0; i < casesLengthI && i < subprogramsLengthI; i++) {
		if (debug > 4) printf ("TRAIL %d Begins\n", i);
		int flag = 1;
		for (int j = 0; j < casesLengthJ[i]; j++) {
			for (int k = i; k >= 0; k-=2) execute (cases[i][j], casesLengthK[i][j], subprograms[i], subprogramsLengthJ[i]);
			for (int k = i; k >= 0; k-=2) {
				if (debug > 5) {
					printf(" :: ");
					printList (cases[i][j], casesLengthK[i][j]);
				} if (!isSorted (cases[i][j], casesLengthK[i][j])) {
					if (debug > 4) printf ("You Have Failed TRAIL %d\n", i);
					flag = 0;
					break;
				}
			}
			if (flag == 0) break;
			if (i > 1) {
				execute (subprograms[i], subprogramsLengthJ[i], subprograms[i], subprogramsLengthJ[i]);
				if (debug > 5) {
					printf(" :: ");
					printList (subprograms[i], subprogramsLengthJ[i]);
				} if (!isSorted (subprograms[i], subprogramsLengthJ[i])) {
					if (debug > 4) printf ("You Have Failed TRAIL %d\n", i);
					flag = 0;
					break;
				}
			}
			if (flag == 0) break;
		}
		if (flag) {
			if (debug > 4) printf ("You Have Passed TRAIL %d\n", i);
			complete++;
		}
	}
	if (debug > 4) for (int i = subprogramsLengthI; i < casesLengthI; i++) printf ("You Have Failed TRAIL %d By Default\n", i);

	if (complete >= requiredComplete) {
		if (debug > 4) puts ("You Have Completed The TRAILS\nThe Input Will Now Be Sorted");
		sort (list, length);
	} else if (debug > 4) printf ("You Have Not Completed Enough TRAILS\nPlease Complete %d More TRAILS", requiredComplete - complete);
	return;
}
int main (int argc, char** argv) {
	if (argc != 3) doBetter ();

	int* list;
	const int length = loadBytes (argv[1], &list);

	int* program;
	const int programLength = loadBytes (argv[2], &program);

	if (programLength > 100) doBetter ();

	if (program[0] == 255) {
		if (debug > 5) printList (list, length);
		if (debug > 4) puts ("TRAILS MODE ENGAGED");

		int subprogramsLengthI = 0;
		for (int i = 0; i < programLength; i++) if (program[i] == 255) subprogramsLengthI++;

		int** subprograms = (int**) malloc (subprogramsLengthI * sizeof (int*));
		int* subprogramsLengthJ = (int*) malloc (subprogramsLengthI * sizeof (int));
		
		int j = programLength - 1, k = subprogramsLengthI - 1;
		for (int i = j; i >= 0; i--) if (program[i] == 255) {
			subprograms[k] = program + i + 1;
			subprogramsLengthJ[k] = (j - i);
			k--;
			j = i - 1;
		}
		
		TRAILS (list, length, subprograms, subprogramsLengthJ, subprogramsLengthI);

		free (subprograms);
		free (subprogramsLengthJ);
	} else execute (list, length, program, programLength);

	printList (list, length);

	int notSorted = 1 - isSorted (list, length);
	if (notSorted && debug > 5) {
		puts ("Not Sorted!");
		if (debug > 8) {
			sort (list, length);
			printList (list, length);
		}
	}

	free (list);
	free (program);
	return notSorted;
}

./compiler.py ${1-inp.HNI} inp.BIN &&
./compiler.py ${2-prg.HNI} prg.BIN &&
./interpreter inp.BIN prg.BIN