139 lines
4.2 KiB
Python
Executable file
139 lines
4.2 KiB
Python
Executable file
#!/usr/bin/env python
|
|
|
|
import copy
|
|
import enum
|
|
import sys
|
|
from typing import NamedTuple
|
|
|
|
|
|
class OpCode(enum.StrEnum):
|
|
ADDR = "addr"
|
|
ADDI = "addi"
|
|
MULR = "mulr"
|
|
MULI = "muli"
|
|
BANR = "banr"
|
|
BANI = "bani"
|
|
BORR = "borr"
|
|
BORI = "bori"
|
|
SETR = "setr"
|
|
SETI = "seti"
|
|
GTIR = "gtir"
|
|
GTRI = "gtri"
|
|
GTRR = "gtrr"
|
|
EQIR = "eqir"
|
|
EQRI = "eqri"
|
|
EQRR = "eqrr"
|
|
|
|
def apply(self, registers: list[int], a: int, b: int, c: int) -> list[int]:
|
|
registers = copy.deepcopy(registers)
|
|
if self == OpCode.ADDR:
|
|
registers[c] = registers[a] + registers[b]
|
|
if self == OpCode.ADDI:
|
|
registers[c] = registers[a] + b
|
|
if self == OpCode.MULR:
|
|
registers[c] = registers[a] * registers[b]
|
|
if self == OpCode.MULI:
|
|
registers[c] = registers[a] * b
|
|
if self == OpCode.BANR:
|
|
registers[c] = registers[a] & registers[b]
|
|
if self == OpCode.BANI:
|
|
registers[c] = registers[a] & b
|
|
if self == OpCode.BORR:
|
|
registers[c] = registers[a] | registers[b]
|
|
if self == OpCode.BORI:
|
|
registers[c] = registers[a] | b
|
|
if self == OpCode.SETR:
|
|
registers[c] = registers[a]
|
|
if self == OpCode.SETI:
|
|
registers[c] = a
|
|
if self == OpCode.GTIR:
|
|
registers[c] = a > registers[b]
|
|
if self == OpCode.GTRI:
|
|
registers[c] = registers[a] > b
|
|
if self == OpCode.GTRR:
|
|
registers[c] = registers[a] > registers[b]
|
|
if self == OpCode.EQIR:
|
|
registers[c] = a == registers[b]
|
|
if self == OpCode.EQRI:
|
|
registers[c] = registers[a] == b
|
|
if self == OpCode.EQRR:
|
|
registers[c] = registers[a] == registers[b]
|
|
return registers
|
|
|
|
|
|
class Instruction(NamedTuple):
|
|
op: OpCode
|
|
a: int
|
|
b: int
|
|
c: int
|
|
|
|
def apply(self, registers: list[int]) -> list[int]:
|
|
return self.op.apply(registers, self.a, self.b, self.c)
|
|
|
|
|
|
def solve(input: str) -> int:
|
|
def parse_instruction(input: str) -> Instruction:
|
|
op, *values = input.split()
|
|
return Instruction(OpCode(op), *map(int, values))
|
|
|
|
def parse(input: list[str]) -> tuple[int, list[Instruction]]:
|
|
ip = int(input[0].removeprefix("#ip "))
|
|
return ip, [parse_instruction(line) for line in input[1:]]
|
|
|
|
def hash_loop(n: int, seed: int, perturb: int) -> int:
|
|
n |= 0x10000 #
|
|
while n:
|
|
seed += n & 0xFF
|
|
seed &= 0xFFFFFF # Keeps 24-bit
|
|
seed *= perturb
|
|
seed &= 0xFFFFFF # Keeps 24-bit
|
|
n >>= 8
|
|
return seed
|
|
|
|
# Relies heavily on input having a specific shape
|
|
def hash_params(ip_reg: int, instructions: list[Instruction]) -> tuple[int, int]:
|
|
def seed_index() -> int:
|
|
for i, instr in enumerate(instructions):
|
|
if instr.op == OpCode.BORI and instr.b == 65536:
|
|
return i + 1
|
|
assert False # Sanity check
|
|
|
|
def perturb_index() -> int:
|
|
for i, instr in enumerate(instructions):
|
|
if instr.op == OpCode.BANI and instr.b == 16777215:
|
|
return i + 1
|
|
assert False # Sanity check
|
|
|
|
seed_instr = instructions[seed_index()]
|
|
perturb_instr = instructions[perturb_index()]
|
|
|
|
assert seed_instr.op == OpCode.SETI # Sanity check
|
|
assert perturb_instr.op == OpCode.MULI # Sanity check
|
|
assert perturb_instr.a == perturb_instr.c # Sanity check
|
|
return seed_instr.a, perturb_instr.b
|
|
|
|
def find_comparison(ip_reg: int, instructions: list[Instruction]) -> int:
|
|
seed, perturb = hash_params(ip_reg, instructions)
|
|
value = 0
|
|
count = 0
|
|
seen: set[int] = set()
|
|
while True:
|
|
count += (value << 8) + (value << 16)
|
|
if (new_value := hash_loop(value, seed, perturb)) in seen:
|
|
return value
|
|
seen.add(new_value)
|
|
value = new_value
|
|
assert False # Sanity check
|
|
|
|
ip_reg, instructions = parse(input.splitlines())
|
|
return find_comparison(ip_reg, instructions)
|
|
|
|
|
|
def main() -> None:
|
|
input = sys.stdin.read()
|
|
print(solve(input))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|