-x00: 1

-x01: 0

-x02: 0

-x03: 1

-x04: 1

-x05: 1

-x06: 0

-x07: 0

-x08: 0

-x09: 1

-x10: 0

-x11: 0

-x12: 0

-x13: 0

-x14: 0

-x15: 1

-x16: 1

-x17: 0

-x18: 1

-x19: 0

-x20: 0

-x21: 0

-x22: 0

-x23: 1

-x24: 1

-x25: 0

-x26: 0

-x27: 0

-x28: 1

-x29: 0

-x30: 1

-x31: 0

-x32: 0

-x33: 0

-x34: 1

-x35: 1

-x36: 1

-x37: 0

-x38: 1

-x39: 1

-x40: 0

-x41: 0

-x42: 0

-x43: 1

-x44: 1

-y00: 1

-y01: 1

-y02: 1

-y03: 1

-y04: 0

-y05: 1

-y06: 0

-y07: 1

-y08: 0

-y09: 1

-y10: 1

-y11: 1

-y12: 1

-y13: 1

-y14: 1

-y15: 0

-y16: 0

-y17: 0

-y18: 1

-y19: 1

-y20: 1

-y21: 1

-y22: 1

-y23: 1

-y24: 0

-y25: 1

-y26: 1

-y27: 0

-y28: 1

-y29: 0

-y30: 1

-y31: 0

-y32: 1

-y33: 0

-y34: 1

-y35: 1

-y36: 0

-y37: 1

-y38: 0

-y39: 0

-y40: 0

-y41: 0

-y42: 0

-y43: 0

-y44: 1

-

-rds AND wpc -> cmj

-vbn XOR mkk -> z13

-y04 AND x04 -> bbw

-ftn OR swv -> bmw

-dkj AND gqs -> vbm

-x38 XOR y38 -> bhv

-jhh XOR vws -> z04

-y38 AND x38 -> tbv

-whm AND rbn -> tpt

-fkf XOR whs -> z31

-x37 XOR y37 -> bmt

-y43 AND x43 -> jbc

-qkj XOR fdg -> z15

-tsq XOR pmr -> z21

-x11 XOR y11 -> jtg

-x35 XOR y35 -> hqk

-whs AND fkf -> vpr

-y16 XOR x16 -> sbt

-y15 AND x15 -> gmt

-tdp AND qqs -> sph

-bsn OR bdc -> mkk

-y12 AND x12 -> bdc

-qmj OR rmv -> tdp

-fdg AND qkj -> fjw

-wfd XOR cwj -> z36

-rgm OR vgp -> cvt

-vws AND jhh -> shg

-qgd OR ggn -> cvr

-x28 AND y28 -> rtf

-y42 XOR x42 -> jgh

-jsv OR kbr -> cwj

-hdp OR rtr -> gms

-gdm OR kqg -> wpc

-x00 XOR y00 -> z00

-x17 AND y17 -> qqc

-hrt AND sbt -> dfq

-y07 AND x07 -> nsg

-y18 AND x18 -> z18

-mjm AND njj -> bch

-y39 AND x39 -> qnt

-x16 AND y16 -> hsb

-grq XOR vfq -> z28

-rbn XOR whm -> z40

-x25 AND y25 -> rwp

-x41 AND y41 -> hdp

-x42 AND y42 -> ftn

-rcm AND rhd -> qvh

-wsq XOR cvr -> z19

-rwp OR bvm -> gdq

-kgd OR kqf -> z10

-x40 AND y40 -> gkj

-x09 XOR y09 -> rds

-jhm AND fqt -> rtr

-y07 XOR x07 -> jfr

-x35 AND y35 -> kbr

-sqr XOR mwq -> mwk

-hmc AND brk -> pjk

-y23 XOR x23 -> gwq

-tdd OR nsg -> cct

-y14 XOR x14 -> njj

-wtm XOR phh -> z06

-wws AND cdh -> dff

-thq XOR mfd -> z17

-y13 XOR x13 -> vbn

-y24 XOR x24 -> hsw

-x12 XOR y12 -> jnk

-vvj OR hph -> jsp

-swf XOR hqk -> z35

-jjg OR pjp -> tqk

-vbm OR wss -> whs

-x22 XOR y22 -> kdn

-y11 AND x11 -> pjp

-x08 XOR y08 -> cjn

-std XOR jfr -> z07

-tjj OR vpp -> jhh

-pjk OR vpj -> rhd

-vkd XOR vtd -> z34

-cjn AND cct -> kqg

-hnw OR nth -> phh

-x30 AND y30 -> wss

-ptr OR dnq -> wrn

-wfd AND cwj -> vvj

-wpd AND ndm -> jcq

-jmh XOR mrs -> z24

-x29 XOR y29 -> wws

-x33 AND y33 -> wvp

-y02 AND x02 -> wwc

-nfh XOR nqq -> qgd

-y30 XOR x30 -> gqs

-jcq OR qnt -> rbn

-wws XOR cdh -> z29

-bmn OR cmj -> mwq

-y06 AND x06 -> mgc

-wkt OR ddd -> swf

-phh AND wtm -> cjd

-wvp OR gqp -> vtd

-jhm XOR fqt -> z41

-x20 XOR y20 -> vcn

-gms AND jgh -> swv

-y23 AND x23 -> sdd

-ndb OR qqc -> nfh

-png XOR gdq -> z26

-nfh AND nqq -> ggn

-x40 XOR y40 -> whm

-y33 XOR x33 -> wwp

-sph OR hpb -> vfq

-vjs OR sfm -> cpv

-y43 XOR x43 -> bng

-cct XOR cjn -> z08

-jmh AND mrs -> bmv

-x01 XOR y01 -> brk

-tsq AND pmr -> vjs

-cwt AND mcd -> pcq

-jfr AND std -> tdd

-sbt XOR hrt -> z16

-y20 AND x20 -> twp

-y05 AND x05 -> hnw

-y27 XOR x27 -> qqs

-bmv OR hsw -> mtn

-y10 XOR x10 -> sqr

-bmt XOR jsp -> z37

-sdd OR hcp -> mrs

-shg OR bbw -> ckj

-y04 XOR x04 -> vws

-jsp AND bmt -> mwp

-png AND gdq -> rmv

-mwk XOR jtg -> z11

-twp OR rqv -> tsq

-x19 AND y19 -> dtr

-x18 XOR y18 -> nqq

-wpc XOR rds -> z09

-kdn XOR cpv -> z22

-x31 AND y31 -> vjp

-rtf OR cbh -> cdh

-dkj XOR gqs -> z30

-y34 XOR x34 -> vkd

-mgc OR cjd -> std

-tff AND mtn -> bvm

-gwq AND wrn -> hcp

-vcn AND spr -> rqv

-y44 XOR x44 -> mcd

-y01 AND x01 -> vpj

-vbn AND mkk -> tsd

-tqk AND jnk -> bsn

-x27 AND y27 -> hpb

-bhv AND kqb -> nrc

-spr XOR vcn -> z20

-ckj XOR tbw -> z05

-y22 AND x22 -> ptr

-ckj AND tbw -> nth

-cpv AND kdn -> dnq

-fjw OR gmt -> hrt

-qvh OR wwc -> sgb

-gwq XOR wrn -> z23

-jgh XOR gms -> z42

-y32 AND x32 -> vgp

-mwq AND sqr -> kgd

-gkj OR tpt -> fqt

-x34 AND y34 -> wkt

-x14 AND y14 -> pwr

-y31 XOR x31 -> fkf

-mwk AND jtg -> jjg

-y05 XOR x05 -> tbw

-pwr OR bch -> fdg

-x21 AND y21 -> sfm

-vfq AND grq -> cbh

-x41 XOR y41 -> jhm

-y36 XOR x36 -> wfd

-mcr AND bgf -> rgm

-psb XOR sgb -> z03

-bmw AND bng -> trs

-x02 XOR y02 -> rcm

-jnk XOR tqk -> z12

-dfq OR hsb -> mfd

-vtd AND vkd -> ddd

-bhv XOR kqb -> z38

-y37 AND x37 -> ftj

-fmp OR pcq -> z45

-brk XOR hmc -> z01

-dff OR hcb -> dkj

-cvt AND wwp -> z33

-x13 AND y13 -> vwv

-qqs XOR tdp -> z27

-x26 XOR y26 -> png

-x15 XOR y15 -> qkj

-x17 XOR y17 -> thq

-trs OR jbc -> cwt

-y36 AND x36 -> hph

-x10 AND y10 -> kqf

-x06 XOR y06 -> wtm

-x32 XOR y32 -> mcr

-mtn XOR tff -> z25

-y28 XOR x28 -> grq

-mwp OR ftj -> kqb

-x03 XOR y03 -> psb

-x25 XOR y25 -> tff

-njj XOR mjm -> z14

-y03 AND x03 -> vpp

-x00 AND y00 -> hmc

-mfd AND thq -> ndb

-x26 AND y26 -> qmj

-x29 AND y29 -> hcb

-y19 XOR x19 -> wsq

-bgf XOR mcr -> z32

-vpr OR vjp -> bgf

-rhd XOR rcm -> z02

-bmw XOR bng -> z43

-nrc OR tbv -> ndm

-y24 AND x24 -> jmh

-x44 AND y44 -> fmp

-wwp XOR cvt -> gqp

-cvr AND wsq -> ghw

-x39 XOR y39 -> wpd

-x09 AND y09 -> bmn

-hqk AND swf -> jsv

-y08 AND x08 -> gdm

-sgb AND psb -> tjj

-vwv OR tsd -> mjm

-y21 XOR x21 -> pmr

-cwt XOR mcd -> z44

-ghw OR dtr -> spr

-wpd XOR ndm -> z39

-#[derive(Debug)]

-struct Gate {

- op: fn(u8, u8) -> u8,

- inputs: [usize; 2],

- out: usize,

- run: bool,

-}

-pub fn p1(x: &str) -> impl Display {

- static mut wires: [u8; 15547] = [u8::MAX; 15547];

- let mut gates = Vec::with_capacity(128);

- fn h(gate: [u8; 3]) -> usize {

- // println!("{}", gate.p());

- if gate[1].is_ascii_digit() {

- let [_, b, c] = gate.map(|x| (x - b'0') as usize);

- 15547 + b * 10 + c

- } else {

- let [a, b, c] = gate.map(|x| (x - b'a') as usize);

- a * 26 * 26 + b * 26 + c

- }

- }

- let mut i_ = x.行();

- let mut i = x.as_ptr();

- let mut x = 0;

- let mut y = 0;

- for j in 0..45u64 {

- x |= (unsafe { *i.add(5) - b'0' } as u64) << j;

- unsafe { i = i.add(7) };

- }

- for j in 0..45u64 {

- y |= (unsafe { *i.add(5) - b'0' } as u64) << j;

- unsafe { i = i.add(7) };

- }

- let mut i = i_;

- i.by_ref().take_while(|x| !x.is_empty()).for_each(drop);

- fn gate(x: &[u8]) -> [u8; 3] {

- x.try_into().unwrap()

- }

- fn and(a: u8, b: u8) -> u8 {

- a & b

- }

- fn or(a: u8, b: u8) -> u8 {

- a | b

- }

- fn xor(a: u8, b: u8) -> u8 {

- a ^ b

- }

- let mut z = 0;

- for connection in i {

- let mut i = connection.split(|x| *x == b' ');

- let [i1, op, i2, _, out] = std::array::from_fn(|_| i.Δ());

- let [i1, i2, out] = [i1, i2, out].map(gate);

- let op = match op {

- b"AND" => and,

- b"OR" => or,

- b"XOR" => xor,

- _ => unreachable!(),

- };

- if i1[0] == b'y' || i1[0] == b'x' {

- let index = (i1[1] - b'0') * 10 + (i1[2] - b'0');

- let res = op((y & 1 << index != 0) as u8, (x & 1 << index != 0) as u8);

- if out[0] != b'z' {

- unsafe { wires[h(out)] = res };

- } else {

- z |= (res as u64) << index;

- gates.push(Gate {

- op,

- run: false,

- inputs: [h(i1), h(i2)],

- out: h(out),

- });

- let mut all_run = false;

- while !all_run {

- all_run = true;

- for gate in &mut gates {

- if gate.run {

- continue;

- };

- unsafe {

- let [a, b] = gate.inputs;

- let a = wires[a];

- if a != u8::MAX

- && let b = wires[b]

- && b != u8::MAX

- {

- gate.run = true;

- if gate.out > 15547 {

- let index = gate.out - 15547;

- z |= ((gate.op)(a, b) as u64) << index;

- } else {

- wires[gate.out] = (gate.op)(a, b);

- }

- }

- all_run &= gate.run;

- }

- }

- z

-}

-

-#[no_mangle]

-pub fn p2(x: &str) -> impl Display {

- let mut gates = Vec::with_capacity(128);

- let x = &x.as_bytes()[7 * 45 * 2 + 1..];

- fn gate(x: &[u8]) -> [u8; 3] {

- x.try_into().unwrap()

- }

- const XOR: u8 = 0;

- const AND: u8 = 1;

- const OR: u8 = 2;

- for connection in x.行() {

- let mut i = connection.split(|x| *x == b' ');

- let [i1, op, i2, _, out] = std::array::from_fn(|_| i.Δ());

- let [i1, i2, out] = [i1, i2, out].map(gate);

- let op = match op {

- b"XOR" => XOR,

- b"AND" => AND,

- b"OR" => OR,

- _ => shucks!(),

- };

- gates.push((i1, i2, out, op));

- }

- let find = |i1, op: u8, i2| {

- gates

- .iter()

- .find(|x| {

- (x.0 == i1 && x.1 == i2 && x.3 == op) || (x.1 == i1 && x.0 == i2 && x.3 == op)

- })

- .map(|x| x.2)

- };

- let find_using = |op: u8, i2| {

- gates.iter().find_map(|x| {

- (x.1 == i2 && x.3 == op)

- .then_some((x.0, x.2))

- .or((x.0 == i2 && x.3 == op).then_some((x.1, x.2)))

- })

- };

- // search for full adders (this is a ripple carry adder)

- // x ^ y -> t0

- // x & y -> t1

- // c0 & t0 -> t2

- // c0 ^ t0 -> z

- // t1 | t2 -> c1

- let mut swaps = vec![];

- for [x, y, should_z] in const {

- let input: [[[u8; 3]; 3]; 44] = car::from_fn!(|i| {

- let i = i + 1;

- let x = [b'x', (i as u8 / 10) + b'0', (i as u8 % 10) + b'0'];

- let y = [b'y', (i as u8 / 10) + b'0', (i as u8 % 10) + b'0'];

- let z = [b'z', (i as u8 / 10) + b'0', (i as u8 % 10) + b'0'];

- [x, y, z]

- });

- input

- } {

- let t0 = find(x, XOR, y).unwrap(); // x ^ y -> t0

-

- // println!("{} ^ {} -> {} (t0)", x.p(), y.p(), t0.p());

-

- let t1 = find(x, AND, y).unwrap(); // x & y -> t1

-

- // println!("{} & {} -> {} (t1)", x.p(), y.p(), t1.p());

-

- // c0 & t0 -> t2

- let Some((_c0, _t2)) = find_using(AND, t0) else {

- swaps.push(t0);

- swaps.push(t1);

- // println!("swap {} with {}", t0.p(), t1.p());

- continue;

- };

- // println!("(c0) {} & {} (t0) -> {} (t2)", c0.p(), t0.p(), t2.p());

- let (_, z) = find_using(XOR, t0).unwrap(); // c0 ^ t0 -> z

-

- // println!("(c0) {} ^ {} (t0) -> {} (z)", c0.p(), t0.p(), z.p());

- if z != should_z {

- swaps.push(z);

- swaps.push(should_z);

- // println!("swap {} with {}", z.p(), format!("z{i:02}"));

- continue;

- // t1 | t2 -> c1

- // let c1 = find(t1, b"OR", t2).unwrap();

- }

- swaps.sort_unstable();

- let mut out = String::with_capacity(40);

- for swap in swaps {

- use std::fmt::Write;

- _ = write!(out, "{},", swap.p());

- out

- println!("{}", unsafe { p2(s) });