Added new question: bytecode interpreter

Author: TianLangHin

competition/bytecode/.gitignore

@@ -0,0 +1 @@
+/target

competition/bytecode/Cargo.lock

@@ -0,0 +1,8 @@
+[package]
+name = "bytecode"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+rand = "0.9.1"
+rand_chacha = "0.9.0"

competition/bytecode/Cargo.toml

@@ -0,0 +1,145 @@
+---toml
+[fuzz]
+exec = ["cargo", "run", "--release", "--", "generate"]
+env = {}
+
+[judge]
+exec = ["cargo", "run", "--release", "--quiet", "--", "validate"]
+
+[problem]
+points = 10
+difficulty = 1
+---
+
+# 📜 Bytecode Interpreter
+
+Congratulations! You've been hired as part of a top-secret division that
+specialises in decoding badly-coded machines.
+As your initiation, your manager has decided it's best for you to dive right into
+a typical day-to-day task that you'll have to carry out.
+
+Next thing you know, your manager has put a massive sequence of archaic bytecode instructions
+on your desk, together with some sort of key that translates what each of the instructions do.
+
+Initially, your manager (not knowing any better) asked you to run the code until termination
+and report to him what the output is.
+Thankfully, you remembered that the
+[Halting Problem](https://en.wikipedia.org/wiki/Halting_problem)
+is undecidable, and thus you managed to avoid an impossible task.
+
+Your manager is quick on their feet though.
+You're now given the following task.
+**Given a series of bytecode instructions, if you run it for 10,000,000 steps,
+what will the sum of all the variables be, and what value will the output register have?**
+
+Firstly, here's a brief layout of the machine.
+It has three components used for storing values:
+* A **namespace**, where variables named by a single lowercase character (a-z)
+  can store one signed 64-bit integer and are always initialised to `0`
+  at the start of the program,
+* A **stack**, where values (always signed 64-bit integers)
+  are stored and retrieved in a first-in-last-out fashion, and
+* An **output register**, which functions just like a regular variable in the namespace,
+  but is referred to in instructions by a `!` symbol, and is initialised to `1`.
+
+Next, here is a list of all types of bytecode instructions it supports.
+* `LOAD <value>`: Puts a copy of `<value>` on the top of the **stack**.
+* `STORE <value>`: Stores the value at the top of the **stack**
+  in the place indicated by `<value>`. If the **stack** is currently empty,
+  a `0` value is placed.
+  `<value>` in this case will *never* be an integer.
+* `LABEL <name>`: Does nothing, but counts as an instruction.
+  Acts as a point in the bytecode that other instructions can jump to.
+* `JUMP <name>`: Jump to the line that contains a `LABEL` instruction
+  associated with the same `<name>`.
+  Such a `LABEL` line is guaranteed to exist such that any `JUMP` is valid,
+  and that exactly *one* line will match, making this instruction always unambiguous.
+* `ADD <value> <value>`: Add the two `<value>`s and push the result on the top of the **stack**.
+* `SUB <value> <value>`: Subtract the second `<value>` from the first `<value>`
+  and push the result on the top of the **stack**.
+* `MUL <value> <value>`: Multiply the two `<value>`s together
+  and push the result on the top of the **stack**.
+* `DIVMOD <value> <value>`: Conduct a division of the first `<value>` by the second `<value>`.
+  First push the quotient of the division onto the **stack**,
+  then push the remainder (modulo) of the division onto the **stack**.
+  If, however, the second `<value>` is zero, then instead of the quotient and remainder,
+  push the original `<value>`s onto the **stack** instead.
+  (i.e., push the first `<value>` first, then the second `<value>` next.)
+* `CMP <value> <value>`: Compares the first `<value>` against the second `<value>`.
+  If the two are equal, push `0` onto the **stack**.
+  If the first is greater than the second, push `1` onto the **stack**.
+  If the first is less than the second, push `-1` onto the **stack**.
+* `BRANCHZERO <name>`: Pops off the top value of the **stack**
+  (if empty, the value is taken as `0`). If this value is equal to `0`,
+  jumps to the line that reads `LABEL <name>`.
+* `BRANCHCMP <value> <value> <ordering> <name>`:
+  Compares the first `<value>` against the second `<value>`.
+  If their relation is the same as given by `<ordering>`,
+  then jump to the line that reads `LABEL <name>`.
+  `<ordering>` is one of three values:
+  * `EQ` matches when the first value is equal to the second value,
+  * `GT` matches when the first value is greater than the second value,
+  * `LS` matches when the first value is less than the second value.
+
+In the above, `<value>` can be one of three different formats:
+* A single integer from the range `-50` to `50` inclusive,
+* A single character denoting the value of a variable in the **namespace**,
+* A `!` symbol, denoting the value of the **output register**.
+
+Additionally, every `<name>` consists of three lowercase letters exactly.
+
+## Example
+
+Consider the following sequence of instructions.
+```
+JUMP str
+LABEL pqr
+JUMP end
+LABEL str
+LOAD 6
+STORE a
+LOAD 2
+STORE !
+ADD a !
+STORE b
+BRANCHCMP b 8 EQ pqr
+LABEL end
+```
+The following instructions will be executed:
+1. `JUMP str`: Jumps forward to the line 3 lines down.
+2. `LABEL str`: Does nothing. Moves to the next instruction.
+3. `LOAD 6`: Loads the value `6` onto the stack.
+4. `STORE a`: Pops `6` from the stack, stores it in the variable `a`.
+5. `LOAD 2`: Loads the value `2` onto the stack.
+6. `STORE !`: Pops `2` from the stack, stores it in the output register.
+7. `ADD a !`: Adds the values of the variable `a` and the output register,
+  which is `6 + 2 = 8`. Hence, `8` is loaded onto the stack.
+8. `STORE b`: Pops `8` from the stack, stores it in the variable `b`.
+9. `BRANCHCMP b 8 EQ pqr`: Compares the variable `b` with the value `8`.
+  Since they are equal in value, jump to the line that reads `LABEL pqr` (second from top).
+10. `LABEL pqr`: Does nothing. Moves to the next instruction.
+11. `JUMP end`: Jumps all the way to the last line (which reads `LABEL end`).
+12. `LABEL end`: Does nothing. Moves to the next (non-existent) instruction, thus halting.
+
+At the end, the **namespace** contains the variables `a` with value `6` and `b` with value `8`.
+The **output register** contains the value `2`.
+Hence, the output in this case should be
+```
+14 2
+```
+since the sum of all variables in the namespace is 14.
+
+Also note that in the above, **12** steps were executed.
+
+## Input
+
+Your input is the list of bytecode instructions to be executed.
+Each instruction will be on a new line,
+and the operands to each instruction are space separated.
+
+## Output
+
+Your output should be two space-separated integers.
+The first integer is the sum of all variables in the namespace,
+and the second integer is the value of the output register
+after the 10,000,000 steps have concluded (or after the program halts, whichever is earlier).