24.py

import math
import collections
from collections import Counter
import re
from tqdm import tqdm

PROD = """
x00: 1
x01: 0
x02: 1
x03: 1
x04: 0
x05: 0
x06: 1
x07: 1
x08: 0
x09: 1
x10: 1
x11: 1
x12: 1
x13: 0
x14: 1
x15: 0
x16: 1
x17: 0
x18: 0
x19: 1
x20: 1
x21: 1
x22: 1
x23: 0
x24: 0
x25: 0
x26: 1
x27: 1
x28: 1
x29: 0
x30: 0
x31: 0
x32: 0
x33: 1
x34: 0
x35: 0
x36: 1
x37: 0
x38: 1
x39: 0
x40: 0
x41: 1
x42: 1
x43: 1
x44: 1
y00: 1
y01: 0
y02: 0
y03: 1
y04: 1
y05: 0
y06: 0
y07: 0
y08: 0
y09: 0
y10: 0
y11: 1
y12: 0
y13: 1
y14: 0
y15: 0
y16: 1
y17: 1
y18: 0
y19: 0
y20: 1
y21: 1
y22: 0
y23: 1
y24: 1
y25: 0
y26: 0
y27: 0
y28: 1
y29: 0
y30: 0
y31: 0
y32: 0
y33: 1
y34: 1
y35: 0
y36: 0
y37: 1
y38: 0
y39: 1
y40: 0
y41: 0
y42: 0
y43: 1
y44: 1

x00 AND y00 -> wrs
y35 XOR x35 -> cbq
y19 XOR x19 -> sdc
dpv AND cwm -> tpd
x01 AND y01 -> rkd
vcb OR frw -> gmg
x32 XOR y32 -> wrh
kmw AND gdq -> crq
y44 AND x44 -> nkv
gnj OR frt -> jkv
y32 AND x32 -> qrk
x08 AND y08 -> fqc
x44 XOR y44 -> nbf
y02 AND x02 -> hjh
y13 AND x13 -> njs
hjc OR kpd -> mjq
jkv AND dcr -> qwq
jpf XOR qqj -> z41
x27 XOR y27 -> ppk
kmw XOR gdq -> z22
pjg XOR kmg -> frt
rdj AND wtf -> mhg
rhf AND cvh -> ntn
nkv OR wmj -> z45
tff OR rrr -> z11
pwc AND jjw -> frw
x09 AND y09 -> bjj
y04 XOR x04 -> jth
npm OR mkq -> wbk
bbw OR cht -> vdg
bmt AND jkm -> pvd
qdp AND sdc -> njb
x11 AND y11 -> rrr
kmg AND pjg -> z23
y12 XOR x12 -> fqr
x03 XOR y03 -> fph
rhn XOR fjq -> z31
y08 XOR x08 -> gjp
y19 AND x19 -> kdt
gjp AND dws -> djd
y14 XOR x14 -> khg
tst OR hvm -> jkm
x42 XOR y42 -> hfh
nwb OR mhg -> cnh
gmg AND nbf -> wmj
y16 AND x16 -> ngh
x41 AND y41 -> mtm
y04 AND x04 -> qgm
y06 XOR x06 -> bmt
x07 XOR y07 -> qcb
x37 AND y37 -> brw
knv XOR wjp -> z36
jth AND bbh -> csc
kwk OR vhr -> hkc
jth XOR bbh -> z04
nfd XOR pvq -> z18
dbp XOR dpt -> z29
pgn AND qcb -> vsr
fbq OR fhw -> wjp
x15 AND y15 -> fjp
x24 AND y24 -> cjj
ktr AND ssd -> cdr
qcb XOR pgn -> z07
mtm OR jmm -> wgw
jkv XOR dcr -> z24
pfs OR crq -> kmg
sdc XOR qdp -> z19
cbq AND hhc -> fbq
fjq AND rhn -> cht
ppk XOR qcs -> z27
pqd OR rsb -> qqj
y12 AND x12 -> bsn
y27 AND x27 -> kpd
x23 XOR y23 -> pjg
x05 AND y05 -> z05
vsr OR bqv -> dws
x17 XOR y17 -> csp
mdn XOR chk -> z34
x43 AND y43 -> vcb
ckj AND wvk -> jwh
rhc XOR vfj -> z16
tpn OR tdf -> npt
x18 XOR y18 -> pvq
hnk XOR cnh -> z40
x37 XOR y37 -> cwm
x33 XOR y33 -> nwp
hdr OR ngh -> jkk
fqb OR hhh -> dpv
sps XOR fqr -> z12
hfh XOR wgw -> z42
jjw XOR pwc -> z43
x35 AND y35 -> fhw
x42 AND y42 -> nwf
pvd OR rcg -> pgn
wtf XOR rdj -> z39
y25 XOR x25 -> wvk
kjs OR rds -> nfd
x07 AND y07 -> bqv
gmg XOR nbf -> z44
hhc XOR cbq -> z35
hfw OR jfh -> dbp
x38 XOR y38 -> pmd
vdg XOR wrh -> z32
y39 XOR x39 -> wtf
wbk XOR qfh -> z21
csp AND jkk -> kjs
x26 AND y26 -> jgh
ppk AND qcs -> hjc
x05 XOR y05 -> vtn
hkc XOR tdd -> sps
y16 XOR x16 -> rhc
x29 XOR y29 -> dpt
y21 AND x21 -> dvg
y40 AND x40 -> rsb
tfd OR rkd -> ktr
vdg AND wrh -> qgr
qfh AND wbk -> svw
vhv OR bjj -> cds
ckj XOR wvk -> z25
x43 XOR y43 -> jjw
fsb OR pmd -> rdj
jwh OR mnt -> cvh
hnk AND cnh -> pqd
x36 XOR y36 -> knv
jkm XOR bmt -> z06
y40 XOR x40 -> hnk
x09 XOR y09 -> wmk
wjn XOR cqf -> z15
x30 XOR y30 -> brt
dpv XOR cwm -> z37
njb OR kdt -> mnv
y38 AND x38 -> cgh
x28 XOR y28 -> qhs
wgw AND hfh -> fvp
gcd AND cgh -> fsb
fnf OR wpn -> bbh
x20 XOR y20 -> nmf
y22 AND x22 -> pfs
y15 XOR x15 -> wjn
x11 XOR y11 -> tdd
x31 AND y31 -> bbw
wmq AND wrs -> tfd
x39 AND y39 -> nwb
wmk XOR cvd -> z09
vgk XOR khg -> z14
cds XOR vdr -> z10
y10 AND x10 -> kwk
wjp AND knv -> fqb
mck OR tbh -> cqf
dfd OR qdm -> mdn
y01 XOR x01 -> wmq
nfd AND pvq -> dvp
x22 XOR y22 -> kmw
vdr AND cds -> vhr
pwv AND nwp -> dfd
cvd AND wmk -> vhv
fjp OR fdv -> vfj
njs OR hgs -> vgk
wmq XOR wrs -> z01
fph XOR vmr -> z03
x31 XOR y31 -> fjq
y29 AND x29 -> tpn
x18 AND y18 -> sjc
khg AND vgk -> tbh
mnv XOR nmf -> z20
sjc OR dvp -> qdp
qhs AND mjq -> hfw
x41 XOR y41 -> jpf
cvh XOR rhf -> z26
y24 XOR x24 -> dcr
y28 AND x28 -> jfh
jmk OR kqd -> hhc
csc OR qgm -> pvb
x06 AND y06 -> rcg
nmf AND mnv -> npm
vtn AND pvb -> hvm
ntn OR jgh -> qcs
pvb XOR vtn -> tst
x34 AND y34 -> jmk
hkc AND tdd -> tff
y00 XOR x00 -> z00
y20 AND x20 -> mkq
x02 XOR y02 -> ssd
pwv XOR nwp -> z33
y33 AND x33 -> qdm
wjn AND cqf -> fdv
y14 AND x14 -> mck
ktr XOR ssd -> z02
qwq OR cjj -> ckj
npt XOR brt -> z30
djd OR fqc -> cvd
brw OR tpd -> gcd
jkk XOR csp -> z17
mdn AND chk -> kqd
cdr OR hjh -> vmr
gjp XOR dws -> z08
qgr OR qrk -> pwv
x30 AND y30 -> fnw
jpn OR fnw -> rhn
x13 XOR y13 -> whw
dbp AND dpt -> tdf
fph AND vmr -> fnf
qhs XOR mjq -> z28
whw XOR bvk -> z13
jpf AND qqj -> jmm
y17 AND x17 -> rds
bsn OR cwh -> bvk
x34 XOR y34 -> chk
x03 AND y03 -> wpn
x10 XOR y10 -> vdr
y23 AND x23 -> gnj
y36 AND x36 -> hhh
cgh XOR gcd -> z38
x26 XOR y26 -> rhf
bvk AND whw -> hgs
vfj AND rhc -> hdr
brt AND npt -> jpn
y21 XOR x21 -> qfh
sps AND fqr -> cwh
svw OR dvg -> gdq
y25 AND x25 -> mnt
nwf OR fvp -> pwc
"""

# 'bbh', 'bbw', 'bjj', 'bmt', 'bqv', 'brt', 'brw', 'bsn', 'bvk', 'cbq', 'cdr', 'cds', 'cgh', 'chk', 'cht', 'cjj', 'ckj', 'cqf', 'crq', 'csc', 'csp', 'cvd', 'cvh', 'cwh', 'cwm', 'dbp', 'dcr', 'dfd', 'djd', 'dpt', 'dpv', 'dvg', 'dvp', 'dws', 'fbq', 'fdv', 'fhw', 'fjp', 'fjq', 'fnf', 'fnw', 'fph', 'fqb', 'fqc', 'fqr', 'frt', 'gcd', 'gdq', 'gjp', 'gnj', 'hdr', 'hfw', 'hgs', 'hhc', 'hhh', 'hjc', 'hjh', 'hkc', 'hvm', 'jfh', 'jgh', 'jkk', 'jkm', 'jkv', 'jmk', 'jpn', 'jth', 'jwh', 'kdt', 'khg', 'kjs', 'kmg', 'kmw', 'knv', 'kpd', 'kqd', 'ktr', 'kwk', 'mck', 'mdn', 'mjq', 'mkq', 'mnt', 'mnv', 'nfd', 'ngh', 'njb', 'njs', 'nmf', 'npm', 'npt', 'ntn', 'nwp', 'pfs', 'pgn', 'pjg', 'ppk', 'pvb', 'pvd', 'pvq', 'pwv', 'qcb', 'qcs', 'qdm', 'qdp', 'qfh', 'qgm', 'qgr', 'qhs', 'qrk', 'qwq', 'rcg', 'rds', 'rhc', 'rhf', 'rhn', 'rkd', 'sdc', 'sjc', 'sps', 'ssd', 'svw', 'tbh', 'tdd', 'tdf', 'tfd', 'tpd', 'tpn', 'tst', 'vdg', 'vdr', 'vfj', 'vgk', 'vhr', 'vhv', 'vmr', 'vsr', 'vtn', 'wbk', 'whw', 'wjn', 'wjp', 'wmk', 'wmq', 'wpn', 'wrh', 'wrs', 'wvk'

rep1 = "z05"
rep2 = "tst"

PROD = PROD.replace("-> " + rep1, "-> " + "TEMP")
PROD = PROD.replace("-> " + rep2, "-> " + rep1)
PROD = PROD.replace("-> " + "TEMP", "-> " + rep2)

rep1 = "z11"
rep2 = "sps"

PROD = PROD.replace("-> " + rep1, "-> " + "TEMP")
PROD = PROD.replace("-> " + rep2, "-> " + rep1)
PROD = PROD.replace("-> " + "TEMP", "-> " + rep2)

rep1 = "z23"
rep2 = "frt"

PROD = PROD.replace("-> " + rep1, "-> " + "TEMP")
PROD = PROD.replace("-> " + rep2, "-> " + rep1)
PROD = PROD.replace("-> " + "TEMP", "-> " + rep2)

# AAAAAA
rep1 = "cgh"
rep2 = "pmd"

PROD = PROD.replace("-> " + rep1, "-> " + "TEMP")
PROD = PROD.replace("-> " + rep2, "-> " + rep1)
PROD = PROD.replace("-> " + "TEMP", "-> " + rep2)


# x = TEST
x = PROD
x = x.strip()

# Data in differnt formats for quick access
text = x
lines = x.split("\n")
grid = [list(line) for line in lines]


regs = {}

init_values, instructions = text.split("\n\n")
init_values = init_values.split("\n")
instructions = instructions.split("\n")

for line in init_values:
    reg, val = line.split(": ")
    regs[reg] = int(val)


for bit in range(44):
    regs = {}

    for j in range(45):
        regs["x" + str(j).zfill(2)] = 0
        regs["y" + str(j).zfill(2)] = 0

    regs[f"x{str(bit).zfill(2)}"] = 1
    # regs[f"y{str(bit).zfill(2)}"] = 1

    executed = [False] * len(instructions)

    while executed.count(False) > 0:
        for i, ins in enumerate(instructions):
            ins = ins.split(" -> ")

            target = ins[1]
            ins = ins[0].split(" ")

            # are both vars available in regs?
            if ins[0] not in regs or ins[2] not in regs:
                continue

            executed[i] = True

            if ins[1] == "AND":
                regs[target] = regs[ins[0]] & regs[ins[2]]
            elif ins[1] == "OR":
                regs[target] = regs[ins[0]] | regs[ins[2]]
            elif ins[1] == "LSHIFT":
                regs[target] = regs[ins[0]] << regs[ins[2]]
            elif ins[1] == "RSHIFT":
                regs[target] = regs[ins[0]] >> regs[ins[2]]
            elif ins[1] == "XOR":
                regs[target] = regs[ins[0]] ^ regs[ins[2]]
            else:
                raise ValueError("Unknown instruction")

    # get all registers that start with z

    s = ""
    # print(regs)

    # print(
    #     "X is",
    # )

    for k in sorted(regs.keys()):
        v = regs[k]
        if k.startswith("z"):
            # print(k, v)
            s = str(v) + str(s)

    actual = 1 << (bit)
    found = int(s, 2)

    if actual != found:
        print(bit, actual, found)

    # print(bit, int(s))
    # print(int(str(int(s))[::1], 2))