d25

day21/d21p1.swift

@@ -0,0 +1,106 @@
+import Foundation
+
+typealias Key = String
+let (nA, nEmpty) = ("A", "")
+let (n7, n8, n9, n4, n5, n6, n1, n2, n3, n0) =
+    ("7", "8", "9", "4", "5", "6", "1", "2", "3", "0")
+let (nL, nR, nU, nD) = ("<", ">", "^", "v")
+
+protocol Pad {
+    static func seq(_ k1: Key, _ k2: Key) -> Set<[Key]>
+}
+
+struct Numpad : Pad {
+    static let pos: [Key: (Int, Int)] = [
+        n7: (0, 0), n8: (0, 1), n9: (0, 2),
+        n4: (1, 0), n5: (1, 1), n6: (1, 2),
+        n1: (2, 0), n2: (2, 1), n3: (2, 2),
+                    n0: (3, 1), nA: (3, 2)
+    ]
+
+    static func seq(_ k1: Key, _ k2: Key) -> Set<[Key]> {
+        let (pos1, pos2) = (pos[k1]!, pos[k2]!)
+        let verKey = pos1.0 < pos2.0 ? nD : nU
+        let horKey = pos1.1 < pos2.1 ? nR : nL
+        let seqs: [[Key]] = [  // ???
+                Array(repeating: verKey, count: abs(pos1.0 - pos2.0)) +
+                Array(repeating: horKey, count: abs(pos1.1 - pos2.1)),
+                Array(repeating: horKey, count: abs(pos1.1 - pos2.1)) +
+                Array(repeating: verKey, count: abs(pos1.0 - pos2.0))
+            ].filter { seq in
+                (k1 != n1 || !seq.starts(with: [nD])) &&
+                (k1 != n4 || !seq.starts(with: [nD, nD])) &&
+                (k1 != n7 || !seq.starts(with: [nD, nD, nD])) &&
+                (k1 != n0 || !seq.starts(with: [nL])) &&
+                (k1 != nA || !seq.starts(with: [nL, nL]))
+            }
+        return Set(seqs)
+    }
+
+}
+
+struct Dirpad : Pad {
+    static let pos: [Key: (Int, Int)] = [
+                    nU: (0, 1), nA: (0, 2),
+        nL: (1, 0), nD: (1, 1), nR: (1, 2)
+    ]
+    static func seq(_ k1: Key, _ k2: Key) -> Set<[Key]> {
+        let (pos1, pos2) = (pos[k1]!, pos[k2]!)
+        let verKey = pos1.0 < pos2.0 ? nD : nU
+        let horKey = pos1.1 < pos2.1 ? nR : nL
+        let seqs: [[Key]] = [  // ???
+                Array(repeating: verKey, count: abs(pos1.0 - pos2.0)) +
+                Array(repeating: horKey, count: abs(pos1.1 - pos2.1)),
+                Array(repeating: horKey, count: abs(pos1.1 - pos2.1)) +
+                Array(repeating: verKey, count: abs(pos1.0 - pos2.0))
+            ].filter { seq in
+                (k1 != nU || !seq.starts(with: [nL])) &&
+                (k1 != nA || !seq.starts(with: [nL, nL])) &&
+                (k1 != nL || !seq.starts(with: [nU]))
+            }
+        return Set(seqs)
+    }
+}
+
+extension Pad {
+    static func press(_ start: Key, _ keys: ArraySlice<Key>) -> [[Key]] {
+        if keys.count == 0 {
+            return [[]]
+        }
+        return seq(start, keys[keys.startIndex]).flatMap { firstSeq in
+            press(keys[keys.startIndex], keys.dropFirst()).map { restSeq in
+                firstSeq + [nA] + restSeq
+            }
+        }
+    }
+}
+
+func readInput(_ filePath: String) throws -> [[Key]] {
+    return try String(contentsOfFile: filePath, encoding: .ascii)
+        .split(separator: "\n").map { Array($0).map(String.init) }
+}
+
+let answer = try readInput(CommandLine.arguments[1]).map { passwd in
+        Numpad.press(nA, passwd[...]).flatMap { dirSeq1 in
+            Dirpad.press(nA, dirSeq1[...]).flatMap { dirSeq2 in
+                Dirpad.press(nA, dirSeq2[...])
+            }
+        }.map { $0.count }.min()! * Int(passwd.joined().dropLast())!
+    }.reduce(0, +)
+print(answer)
+
+//}.forEach { line in
+//    print()
+//    line.map { $0.joined() }.forEach { print("\($0.count): \($0)") }
+//}
+            
+
+/*
+Numpad.press(nA, [n0, n2, n9, nA])
+    .map { $0.joined() }.forEach { print("\($0.count): \($0)") }
+print()
+Dirpad.press(nA, "<A^A^^>AvvvA".map(String.init)[...])
+    .map { $0.joined() }.forEach { print("\($0.count): \($0)") }
+print()
+*/
+

day21/d21p2.swift

@@ -0,0 +1,142 @@
+import Foundation
+
+typealias Key = String
+let (nA, nEmpty) = ("A", "")
+let (n7, n8, n9, n4, n5, n6, n1, n2, n3, n0) =
+    ("7", "8", "9", "4", "5", "6", "1", "2", "3", "0")
+let (nL, nR, nU, nD) = ("<", ">", "^", "v")
+
+protocol Pad {
+    static var pos: [Key: (Int, Int)] { get }
+    static var cache: [[Key]: Set<[Key]>] { get set }
+    static func valid(start: Key, seq: [Key]) -> Bool
+}
+
+extension Pad {
+    // returns set of reasonable key sequences to move from k1 to k2
+    static func seq(_ k1: Key, _ k2: Key) -> Set<[Key]> {
+        if let cached = cache[[k1, k2]] {
+            return cached
+        }
+        let (pos1, pos2) = (pos[k1]!, pos[k2]!)
+        let verKey = pos1.0 < pos2.0 ? nD : nU
+        let horKey = pos1.1 < pos2.1 ? nR : nL
+        let seqs: [[Key]] = [  // ???
+                Array(repeating: verKey, count: abs(pos1.0 - pos2.0)) +
+                Array(repeating: horKey, count: abs(pos1.1 - pos2.1)),
+                Array(repeating: horKey, count: abs(pos1.1 - pos2.1)) +
+                Array(repeating: verKey, count: abs(pos1.0 - pos2.0))
+            ].filter { seq in valid(start: k1, seq: seq) }
+        cache[[k1, k2]] = Set(seqs)
+        return cache[[k1, k2]]!
+    }
+
+    // returns set of possible key sequences to press all |keys| from |start|
+    static func press(_ start: Key, _ keys: ArraySlice<Key>) -> [[Key]] {
+        if keys.count == 0 {
+            return [[]]
+        }
+        return seq(start, keys[keys.startIndex]).flatMap { firstSeq in
+                press(keys[keys.startIndex], keys.dropFirst()).map { restSeq in
+                    firstSeq + [nA] + restSeq
+                }
+            }
+    }
+}
+
+struct Numpad : Pad {
+    static let pos: [Key: (Int, Int)] = [
+        n7: (0, 0), n8: (0, 1), n9: (0, 2),
+        n4: (1, 0), n5: (1, 1), n6: (1, 2),
+        n1: (2, 0), n2: (2, 1), n3: (2, 2),
+                    n0: (3, 1), nA: (3, 2)
+    ]
+    static func valid(start: Key, seq: [Key]) -> Bool {
+        return
+            (start != n1 || !seq.starts(with: [nD])) &&
+            (start != n4 || !seq.starts(with: [nD, nD])) &&
+            (start != n7 || !seq.starts(with: [nD, nD, nD])) &&
+            (start != n0 || !seq.starts(with: [nL])) &&
+            (start != nA || !seq.starts(with: [nL, nL]))
+    }
+    static var cache: [[Key]: Set<[Key]>] = [:]
+}
+
+struct Dirpad : Pad {
+    static let pos: [Key: (Int, Int)] = [
+                    nU: (0, 1), nA: (0, 2),
+        nL: (1, 0), nD: (1, 1), nR: (1, 2)
+    ]
+    static func valid(start: Key, seq: [Key]) -> Bool {
+        return
+            (start != nU || !seq.starts(with: [nL])) &&
+            (start != nA || !seq.starts(with: [nL, nL])) &&
+            (start != nL || !seq.starts(with: [nU]))
+    }
+    static var cache: [[Key]: Set<[Key]>] = [:]
+}
+
+extension Array {
+    func combos(l: Int) -> [[Element]] {
+        guard count > 0 else { return [[]] }
+        if l == 0 { return [[]] }
+        return flatMap { e in
+            combos(l: l - 1).map { $0 + [e] }
+        }
+    }
+    func combos(maxl: Int) -> [[Element]] {
+        return (0...maxl).flatMap { combos(l: $0) }
+    }
+}
+
+struct LKs : Hashable, CustomStringConvertible {
+    let l: Int
+    let ks: [Key]
+    var description: String { return "(\(l),\(ks.joined()))" }
+}
+
+// Returns a lookup table from a sequence of pressed ending at A
+// to how many key presses total for that sequence
+func best(maxLevel: Int) -> [LKs: Int] {
+    var res: [LKs: Int] = [:]
+    [nL, nR, nU, nD].combos(maxl: 3).forEach { seq in
+        let len = Dirpad.press(nA, seq + [nA]).map { $0.count}.min()!
+        res[LKs(l: 1, ks: seq)] = len
+    }
+    var level = 2
+    while level <= maxLevel {
+        let maxl = (level == maxLevel) ? 5 : 3
+        [nL, nR, nU, nD].combos(maxl: maxl).forEach { seq in
+            res[LKs(l: level, ks: Array(seq))] = Dirpad.press(nA, seq + [nA])
+                .map { ks in
+                    ks.split(separator: "A", omittingEmptySubsequences: false)
+                        .dropLast()
+                        .map { res[LKs(l: level-1, ks: Array($0))]! }
+                        .reduce(0, +)
+                }.min()!
+        }
+        level += 1
+    }
+    return res
+}
+
+func readInput(_ filePath: String) throws -> [[Key]] {
+    return try String(contentsOfFile: filePath, encoding: .ascii)
+        .split(separator: "\n").map { Array($0).map(String.init) }
+}
+
+let levels = Int(CommandLine.arguments[2])!
+let bests = best(maxLevel: levels)
+
+var answer = 0
+for passwd in try readInput(CommandLine.arguments[1]) {
+    let cost = Numpad.press(nA, passwd[...]).map { ks in
+            ks.split(separator: "A", omittingEmptySubsequences: false)
+                .dropLast()
+                .map { bests[LKs(l: levels, ks: Array($0))]! }
+                .reduce(0, +)
+        }.min()!
+    answer += cost * Int(passwd.joined().dropLast())!
+}
+print(answer)
+

day21/input.txt

@@ -0,0 +1,5 @@
+169A
+279A
+540A
+869A
+789A

day21/test.txt

@@ -0,0 +1,5 @@
+029A
+980A
+179A
+456A
+379A

day22/d22p1.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+func readInput(_ filePath: String) throws -> [Int] {
+    return try String(contentsOfFile: filePath, encoding: .ascii)
+        .split(separator: "\n").compactMap { Int($0) }
+}
+
+func rand(seed: Int, n: Int) -> Int {
+    return (0..<n).reduce(seed) { prev, _ in
+        var res = ((prev << 6) ^ prev) & 0b111111111111111111111111
+        res = ((res >> 5) ^ res)
+        return ((res << 11) ^ res) & 0b111111111111111111111111
+    }
+}
+
+let seeds = try readInput(CommandLine.arguments[1])
+print(seeds.map { rand(seed: $0, n: 2000) }.reduce(0, +))
+

day22/d22p2.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+func readInput(_ filePath: String) throws -> [Int] {
+    return try String(contentsOfFile: filePath, encoding: .ascii)
+        .split(separator: "\n").compactMap { Int($0) }
+}
+
+func haggle(_ seeds: [Int]) -> [[Int]: [Int: Int]] {
+    var bananas: [[Int]: [Int: Int]] = [:]
+    for (monkey, seed) in seeds.enumerated() {
+        var prevs = [monkey, seed, Int.min, Int.min]
+        var lastPrice = seed
+        for _ in 0..<2000 {
+            var price = ((lastPrice << 6) ^ lastPrice) & 16777215
+            price = ((price >> 5) ^ price)
+            price = ((price << 11) ^ price) & 16777215
+            prevs[0] = prevs[1]; prevs[1] = prevs[2]; prevs[2] = prevs[3]
+            prevs[3] = (price % 10) - (lastPrice % 10)
+            lastPrice = price
+            if let _ = bananas[prevs, default: [:]][monkey] { continue }
+            bananas[prevs, default: [:]][monkey] = price % 10
+        }
+    }
+    return bananas
+}
+
+let seeds = try readInput(CommandLine.arguments[1])
+let bananas = haggle(seeds)
+print(bananas.values.map { $0.values.reduce(0, +) }.max() ?? "ERROR")
+

day22/test.txt

@@ -0,0 +1,4 @@
+1
+10
+100
+2024

day22/test2.txt

@@ -0,0 +1,4 @@
+1
+2
+3
+2024

day23/d23p1.swift

@@ -0,0 +1,43 @@
+import Foundation
+
+typealias Network = [String: Set<String>]
+
+func readInput(_ filePath: String) throws -> Network {
+    var map: Network = [:]
+    try String(contentsOfFile: filePath, encoding: .ascii)
+        .split(separator: "\n").map { $0.split(separator: "-") }
+        .map { (String($0[0]), String($0[1])) }.forEach { m1, m2 in
+            map[m1, default: []].insert(m2)
+            map[m2, default: []].insert(m1)
+        }
+    return map
+}
+
+struct Triple : Hashable, CustomStringConvertible {
+    let (m1, m2, m3): (String, String, String)
+    var description: String { return "\(m1)-\(m2)-\(m3)" }
+    var hasT: Bool {
+        return m1.first == "t" || m2.first == "t" || m3.first == "t"
+    }
+    init (_ m1: String, _ m2: String, _ m3: String) {
+        let ms = [m1, m2, m3].sorted()
+        (self.m1, self.m2, self.m3) = (ms[0], ms[1], ms[2])
+    }
+}
+
+func checkTriples(_ network: Network) -> Set<Triple> {
+    var triples: Set<Triple> = []
+    for (m1, m1conns) in network {
+        for m2 in m1conns {
+            for m3 in network[m2]! {
+                if network[m3]!.contains(m1) {
+                    triples.insert(Triple(m1, m2, m3))
+                }
+            }
+        }
+    }
+    return triples
+}
+            
+let conns = try readInput(CommandLine.arguments[1])
+print(checkTriples(conns).filter { $0.hasT }.count)

day23/d23p2.swift

@@ -0,0 +1,45 @@
+import Foundation
+
+typealias Network = [String: Set<String>]
+
+func readInput(_ filePath: String) throws -> Network {
+    var map: Network = [:]
+    try String(contentsOfFile: filePath, encoding: .ascii)
+        .split(separator: "\n").map { $0.split(separator: "-") }
+        .map { (String($0[0]), String($0[1])) }.forEach { m1, m2 in
+            map[m1, default: []].insert(m2)
+            map[m2, default: []].insert(m1)
+        }
+    return map
+}
+
+func bronkerbosch(
+    _ network: Network, r: Set<String>, p: Set<String>, x: Set<String>
+) -> Set<String>? {
+    if p.count == 0 {
+        return x.count == 0 ? r : nil
+    }
+    var maxClique: Set<String>? = nil
+    var nextP = p
+    var nextX = x
+    let u = p.union(x).first!  // can also choose highest degree node
+    for v in p.subtracting(network[u]!) {
+        if let clique = bronkerbosch(network,
+            r: r.union([v]),
+            p: nextP.intersection(network[v]!),
+            x: nextX.intersection(network[v]!)
+        ) {
+            if clique.count > (maxClique ?? []).count {
+                maxClique = clique
+            }
+        }
+        nextP.remove(v)
+        nextX.insert(v)
+    }
+    return maxClique
+}
+            
+let conns = try readInput(CommandLine.arguments[1])
+let clique = bronkerbosch(conns, r: [], p: Set(conns.keys), x: [])
+print(Array(clique ?? []).sorted().joined(separator: ","))
+

day23/test.txt

@@ -0,0 +1,32 @@
+kh-tc
+qp-kh
+de-cg
+ka-co
+yn-aq
+qp-ub
+cg-tb
+vc-aq
+tb-ka
+wh-tc
+yn-cg
+kh-ub
+ta-co
+de-co
+tc-td
+tb-wq
+wh-td
+ta-ka
+td-qp
+aq-cg
+wq-ub
+ub-vc
+de-ta
+wq-aq
+wq-vc
+wh-yn
+ka-de
+kh-ta
+co-tc
+wh-qp
+tb-vc
+td-yn

day24/d24p1.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+typealias Op = (Bool, Bool) -> Bool
+typealias Gate  = (String, Op, String, String)
+
+struct Circuit : CustomStringConvertible {
+    let gates: [Gate]
+    var nodes: [String: Bool]
+    var pendingEndNodes: Set<String>
+    var description: String {
+        nodes.map { "\($0): \($1 ? 1 : 0)" }.sorted().joined(separator: "\n") +
+        "\n\(pendingEndNodes)"
+    }
+    var value: Int? {
+        if pendingEndNodes.count > 0 { return nil }
+        return nodes.keys.filter { $0.starts(with: "z") }
+            .sorted().reversed().reduce(0) { $0*2 + (nodes[$1]! ? 1 : 0) }
+    }
+    mutating func run(gate: Gate) {
+        let (in1, op, in2, out) = gate
+        if let v1 = nodes[in1], let v2 = nodes[in2] {
+            nodes[out] = op(v1, v2)
+            pendingEndNodes.remove(out)
+        }
+    }
+    mutating func run() {
+        gates.forEach { run(gate: $0) }
+    }
+}
+
+func readInput(_ filePath: String) throws -> Circuit {
+    let content = try String(contentsOfFile: filePath, encoding: .ascii)
+    let nodeRe = try Regex(#"([a-z0-9]+): (0|1)"#)
+    let gateRe = try Regex(#"([a-z0-9]+) (AND|OR|XOR) ([a-z0-9]+) -> ([a-z0-9]+)"#)
+    let opMap: [String: Op] = [
+        "AND": { $0 && $1 },
+        "OR": { $0 || $1 },
+        "XOR": { $0 != $1 }
+    ]
+    var nodes: [String: Bool] = [:]
+    var gates: [Gate] = []
+    var endNodes: Set<String> = []
+    for line in content.split(separator: "\n") {
+        if let m = line.wholeMatch(of: nodeRe) {
+            let node = String(m.output[1].substring!)
+            let val = m.output[2].substring! == "1"
+            nodes[node] = val
+        }
+        if let m = line.wholeMatch(of: gateRe) {
+            let in1 = String(m.output[1].substring!)
+            let op = opMap[String(m.output[2].substring!)]!
+            let in2 = String(m.output[3].substring!)
+            let out = String(m.output[4].substring!)
+            gates.append((in1, op, in2, out))
+            if out.starts(with: "z") {
+                endNodes.insert(out)
+            }
+        }
+    }
+    return Circuit(gates: gates, nodes: nodes, pendingEndNodes: endNodes)
+} 
+
+var circuit = try readInput(CommandLine.arguments[1])
+//print(circuit)
+while true {
+    if let res = circuit.value {
+        print("answer: \(res)")
+        break
+    }
+    circuit.run()
+    //print(circuit)
+}
+

day24/d24p2.swift

@@ -0,0 +1,94 @@
+import Foundation
+
+typealias Op = (Bool, Bool) -> Bool
+typealias Gate  = (String, Op, String, String)
+
+struct Circuit : CustomStringConvertible {
+    let gates: [Gate]
+    var nodes: [String: Bool]
+    var pendingEndNodes: Set<String>
+    var description: String {
+        nodes.map { "\($0): \($1 ? 1 : 0)" }.sorted().joined(separator: "\n") +
+        "\n\(pendingEndNodes)"
+    }
+    func value(of prefix: String) -> Int? {
+        if pendingEndNodes.count > 0 { return nil }
+        return nodes.keys.filter { $0.starts(with: prefix) }
+            .sorted().reversed().reduce(0) { $0 * 2 + (nodes[$1]! ? 1 : 0) }
+    }
+    mutating func run(gate: Gate) {
+        let (in1, op, in2, out) = gate
+        if let v1 = nodes[in1], let v2 = nodes[in2] {
+            nodes[out] = op(v1, v2)
+            pendingEndNodes.remove(out)
+        }
+    }
+    mutating func run() {
+        gates.forEach { run(gate: $0) }
+    }
+}
+
+func readInput(_ filePath: String) throws -> Circuit {
+    let content = try String(contentsOfFile: filePath, encoding: .ascii)
+    let gateRe = try Regex(#"([a-z0-9]+) (AND|OR|XOR) ([a-z0-9]+) -> ([a-z0-9]+)"#)
+    let opMap: [String: Op] = [
+        "AND": { $0 && $1 },
+        "OR": { $0 || $1 },
+        "XOR": { $0 != $1 }
+    ]
+    var gates: [Gate] = []
+    var endNodes: Set<String> = []
+    for line in content.split(separator: "\n") {
+        if let m = line.wholeMatch(of: gateRe) {
+            let in1 = String(m.output[1].substring!)
+            let op = opMap[String(m.output[2].substring!)]!
+            let in2 = String(m.output[3].substring!)
+            let out = String(m.output[4].substring!)
+            gates.append((in1, op, in2, out))
+            if out.starts(with: "z") {
+                endNodes.insert(out)
+            }
+        }
+    }
+    return Circuit(gates: gates, nodes: [:], pendingEndNodes: endNodes)
+} 
+
+extension Int {
+    func toNodes(_ prefix: String) -> [String: Bool] {
+        var nodes: [String: Bool] = [:]
+        for i in (0..<45) {
+            nodes[prefix + String(format: "%02d", i)] = ((self >> i) & 1) == 1
+        }
+        return nodes
+    }
+}
+
+var circuit = try readInput(CommandLine.arguments[1])
+// generate random x y to try
+let x = Int.random(in: 0..<(1<<45))
+let y = Int.random(in: 0..<(1<<45))
+circuit.nodes.merge(x.toNodes("x")) { l, r in l }
+circuit.nodes.merge(y.toNodes("y")) { l, r in l }
+// just print out the wrong bits for manual debugging. See input.dot
+// print(circuit)
+while true {
+    if let z = circuit.value(of: "z") {
+        print("x: " + String(x, radix: 2).reversed())
+        print("y: " + String(y, radix: 2).reversed())
+        let zStr = String(z, radix: 2).reversed()
+        let pStr = String(x+y, radix: 2).reversed()
+        let zHighlight = zip(zStr, pStr).map { dz, dp -> String in
+            dz == dp ? String(dz) : "\u{001B}[41m\(dz)\u{001B}[0m"
+        }
+        print("z: " + zHighlight.joined())
+        print("\u{001B}[4m!: \(String(pStr))\u{001B}[0m")
+        print("   \((0..<zStr.count).map { String($0 % 10) }.joined())")
+        break
+    }
+    circuit.run()
+}
+
+// use graphviz to render input.dot to svg
+// run program to find out first bit that failed (highlighted in red)
+// look at svg around that for irregularities (regular full adders are obvious)
+// in this case z16 <-> fkb and z31 <-> rdn

day24/input.dot

@@ -0,0 +1,225 @@
+digraph G {
+  y16 -> y16x16bss; x16 -> y16x16bss; y16x16bss [label="AND", shape=box]; y16x16bss -> bss
+  wrt -> wrtpssfjs; pss -> wrtpssfjs; wrtpssfjs [label="OR", shape=doubleoctagon]; wrtpssfjs -> fjsC
+  qpd -> qpdhnktdb; hnk -> qpdhnktdb; qpdhnktdb [label="AND", shape=box]; qpdhnktdb -> tdb
+  ncp -> ncpdrdktn; drd -> ncpdrdktn; ncpdrdktn [label="AND", shape=box]; ncpdrdktn -> ktn
+  vnw -> vnwftqkgt; ftq -> vnwftqkgt; vnwftqkgt [label="AND", shape=box]; vnwftqkgt -> kgt
+  y12 -> y12x12dbg; x12 -> y12x12dbg; y12x12dbg [label="XOR", shape=diamond]; y12x12dbg -> dbg
+  y05 -> y05x05jfq; x05 -> y05x05jfq; y05x05jfq [label="AND", shape=box]; y05x05jfq -> jfq
+  x16 -> x16y16grr; y16 -> x16y16grr; x16y16grr [label="XOR", shape=diamond]; x16y16grr -> grr
+  y39 -> y39x39tbr; x39 -> y39x39tbr; y39x39tbr [label="AND", shape=box]; y39x39tbr -> tbr
+  crp -> crpgkkqkk; gkk -> crpgkkqkk; crpgkkqkk [label="AND", shape=box]; crpgkkqkk -> qkk
+  x02 -> x02y02jrf; y02 -> x02y02jrf; x02y02jrf [label="AND", shape=box]; x02y02jrf -> jrf
+  x09 -> x09y09nwn; y09 -> x09y09nwn; x09y09nwn [label="AND", shape=box]; x09y09nwn -> nwn
+  vmf -> vmfbkprjw; bkp -> vmfbkprjw; vmfbkprjw [label="AND", shape=box]; vmfbkprjw -> rjw
+  qpd -> qpdhnkz34; hnk -> qpdhnkz34; qpdhnkz34 [label="XOR", shape=diamond]; qpdhnkz34 -> z34
+  x06 -> x06y06kcc; y06 -> x06y06kcc; x06y06kcc [label="XOR", shape=diamond]; x06y06kcc -> kcc
+  x30 -> x30y30bgj; y30 -> x30y30bgj; x30y30bgj [label="AND", shape=box]; x30y30bgj -> bgj
+  rhk -> rhkbtvrmv; btv -> rhkbtvrmv; rhkbtvrmv [label="AND", shape=box]; rhkbtvrmv -> rmv
+  fjs -> fjsbmvz44; bmv -> fjsbmvz44; fjsbmvz44 [label="XOR", shape=diamond]; fjsbmvz44 -> z44
+  btv -> btvrhkz25; rhk -> btvrhkz25; btvrhkz25 [label="XOR", shape=diamond]; btvrhkz25 -> z25
+  wgk -> wgkpppvnc; ppp -> wgkpppvnc; wgkpppvnc [label="OR", shape=doubleoctagon]; wgkpppvnc -> vncC
+  kcm -> kcmgrrfkb; grr -> kcmgrrfkb; kcmgrrfkb [label="XOR", shape=diamond]; kcmgrrfkb -> fkb
+  fkb -> fkbrccfbb; rcc -> fkbrccfbb; fkbrccfbb [label="AND", shape=box]; fkbrccfbb -> fbb
+  dbd -> dbdshbz15; shb -> dbdshbz15; dbdshbz15 [label="XOR", shape=diamond]; dbdshbz15 -> z15
+  y38 -> y38x38vsq; x38 -> y38x38vsq; y38x38vsq [label="XOR", shape=diamond]; y38x38vsq -> vsq
+  sfs -> sfshmhqpd; hmh -> sfshmhqpd; sfshmhqpd [label="OR", shape=doubleoctagon]; sfshmhqpd -> qpdC
+  bmv -> bmvfjskwh; fjs -> bmvfjskwh; bmvfjskwh [label="AND", shape=box]; bmvfjskwh -> kwh
+  ftq -> ftqvnwz11; vnw -> ftqvnwz11; ftqvnwz11 [label="XOR", shape=diamond]; ftqvnwz11 -> z11
+  cjt -> cjtsvkkcm; svk -> cjtsvkkcm; cjtsvkkcm [label="OR", shape=doubleoctagon]; cjtsvkkcm -> kcmC
+  y33 -> y33x33ttn; x33 -> y33x33ttn; y33x33ttn [label="XOR", shape=diamond]; y33x33ttn -> ttn
+  x18 -> x18y18dwd; y18 -> x18y18dwd; x18y18dwd [label="XOR", shape=diamond]; x18y18dwd -> dwd
+  qpk -> qpkbtqnkn; btq -> qpkbtqnkn; qpkbtqnkn [label="OR", shape=doubleoctagon]; qpkbtqnkn -> nknC
+  nnq -> nnqpfbmfc; pfb -> nnqpfbmfc; nnqpfbmfc [label="OR", shape=doubleoctagon]; nnqpfbmfc -> mfcC
+  crp -> crpgkkz39; gkk -> crpgkkz39; crpgkkz39 [label="XOR", shape=diamond]; crpgkkz39 -> z39
+  x28 -> x28y28dwg; y28 -> x28y28dwg; x28y28dwg [label="AND", shape=box]; x28y28dwg -> dwg
+  y07 -> y07x07ncp; x07 -> y07x07ncp; y07x07ncp [label="XOR", shape=diamond]; y07x07ncp -> ncp
+  ssf -> ssfhqrswq; hqr -> ssfhqrswq; ssfhqrswq [label="AND", shape=box]; ssfhqrswq -> swq
+  mfc -> mfchdkpqk; hdk -> mfchdkpqk; mfchdkpqk [label="AND", shape=box]; mfchdkpqk -> pqk
+  y44 -> y44x44bmv; x44 -> y44x44bmv; y44x44bmv [label="XOR", shape=diamond]; y44x44bmv -> bmv
+  x35 -> x35y35jdq; y35 -> x35y35jdq; x35y35jdq [label="XOR", shape=diamond]; x35y35jdq -> jdq
+  y30 -> y30x30jnr; x30 -> y30x30jnr; y30x30jnr [label="XOR", shape=diamond]; y30x30jnr -> jnr
+  x32 -> x32y32dfn; y32 -> x32y32dfn; x32y32dfn [label="XOR", shape=diamond]; x32y32dfn -> dfn
+  ccw -> ccwfbbhnq; fbb -> ccwfbbhnq; ccwfbbhnq [label="OR", shape=doubleoctagon]; ccwfbbhnq -> hnqC
+  pqk -> pqkdwgrsj; dwg -> pqkdwgrsj; pqkdwgrsj [label="OR", shape=doubleoctagon]; pqkdwgrsj -> rsjC
+  jrk -> jrkcprkgn; cpr -> jrkcprkgn; jrkcprkgn [label="OR", shape=doubleoctagon]; jrkcprkgn -> kgnC
+  x01 -> x01y01kmf; y01 -> x01y01kmf; x01y01kmf [label="AND", shape=box]; x01y01kmf -> kmf
+  kcm -> kcmgrrtnn; grr -> kcmgrrtnn; kcmgrrtnn [label="AND", shape=box]; kcmgrrtnn -> tnn
+  y28 -> y28x28hdk; x28 -> y28x28hdk; y28x28hdk [label="XOR", shape=diamond]; y28x28hdk -> hdk
+  mtb -> mtbjdkfmr; jdk -> mtbjdkfmr; mtbjdkfmr [label="AND", shape=box]; mtbjdkfmr -> fmr
+  y29 -> y29x29ccs; x29 -> y29x29ccs; y29x29ccs [label="XOR", shape=diamond]; y29x29ccs -> ccs
+  vhv -> vhvcbhbtv; cbh -> vhvcbhbtv; vhvcbhbtv [label="OR", shape=doubleoctagon]; vhvcbhbtv -> btvC
+  hdk -> hdkmfcz28; mfc -> hdkmfcz28; hdkmfcz28 [label="XOR", shape=diamond]; hdkmfcz28 -> z28
+  dbg -> dbgbcqwgk; bcq -> dbgbcqwgk; dbgbcqwgk [label="AND", shape=box]; dbgbcqwgk -> wgk
+  x11 -> x11y11ftq; y11 -> x11y11ftq; x11y11ftq [label="XOR", shape=diamond]; x11y11ftq -> ftq
+  y04 -> y04x04mtb; x04 -> y04x04mtb; y04x04mtb [label="XOR", shape=diamond]; y04x04mtb -> mtb
+  vnm -> vnmmgrphc; mgr -> vnmmgrphc; vnmmgrphc [label="AND", shape=box]; vnmmgrphc -> phc
+  jfq -> jfqtswksh; tsw -> jfqtswksh; jfqtswksh [label="OR", shape=doubleoctagon]; jfqtswksh -> kshC
+  gcg -> gcgnbmrrn; nbm -> gcgnbmrrn; gcgnbmrrn [label="XOR", shape=diamond]; gcgnbmrrn -> rrn
+  wdv -> wdvqphmcv; qph -> wdvqphmcv; wdvqphmcv [label="OR", shape=doubleoctagon]; wdvqphmcv -> mcvC
+  x19 -> x19y19pdb; y19 -> x19y19pdb; x19y19pdb [label="AND", shape=box]; x19y19pdb -> pdb
+  rqf -> rqfhvvz21; hvv -> rqfhvvz21; rqfhvvz21 [label="XOR", shape=diamond]; rqfhvvz21 -> z21
+  y27 -> y27x27nnq; x27 -> y27x27nnq; y27x27nnq [label="AND", shape=box]; y27x27nnq -> nnq
+  rdg -> rdgscwjmt; scw -> rdgscwjmt; rdgscwjmt [label="OR", shape=doubleoctagon]; rdgscwjmt -> jmtC
+  qkk -> qkktbrggg; tbr -> qkktbrggg; qkktbrggg [label="OR", shape=doubleoctagon]; qkktbrggg -> gggC
+  jtm -> jtmrqwtsw; rqw -> jtmrqwtsw; jtmrqwtsw [label="AND", shape=box]; jtmrqwtsw -> tsw
+  ccs -> ccsrsjthq; rsj -> ccsrsjthq; ccsrsjthq [label="AND", shape=box]; ccsrsjthq -> thq
+  kgt -> kgtqmmbcq; qmm -> kgtqmmbcq; kgtqmmbcq [label="OR", shape=doubleoctagon]; kgtqmmbcq -> bcqC
+  kwh -> kwhqqrz45; qqr -> kwhqqrz45; kwhqqrz45 [label="OR", shape=doubleoctagon]; kwhqqrz45 -> z45C
+  twj -> twjqftz08; qft -> twjqftz08; twjqftz08 [label="XOR", shape=diamond]; twjqftz08 -> z08
+  ttn -> ttnjmthmh; jmt -> ttnjmthmh; ttnjmthmh [label="AND", shape=box]; ttnjmthmh -> hmh
+  y44 -> y44x44qqr; x44 -> y44x44qqr; y44x44qqr [label="AND", shape=box]; y44x44qqr -> qqr
+  x03 -> x03y03mgr; y03 -> x03y03mgr; x03y03mgr [label="XOR", shape=diamond]; x03y03mgr -> mgr
+  x40 -> x40y40ntw; y40 -> x40y40ntw; x40y40ntw [label="AND", shape=box]; x40y40ntw -> ntw
+  jmt -> jmtttnz33; ttn -> jmtttnz33; jmtttnz33 [label="XOR", shape=diamond]; jmtttnz33 -> z33
+  x43 -> x43y43dnf; y43 -> x43y43dnf; x43y43dnf [label="XOR", shape=diamond]; x43y43dnf -> dnf
+  rmv -> rmvsmjhnv; smj -> rmvsmjhnv; rmvsmjhnv [label="OR", shape=doubleoctagon]; rmvsmjhnv -> hnvC
+  y17 -> y17x17ccw; x17 -> y17x17ccw; y17x17ccw [label="AND", shape=box]; y17x17ccw -> ccw
+  y22 -> y22x22jck; x22 -> y22x22jck; y22x22jck [label="XOR", shape=diamond]; y22x22jck -> jck
+  tph -> tphhbkjhd; hbk -> tphhbkjhd; tphhbkjhd [label="AND", shape=box]; tphhbkjhd -> jhd
+  x34 -> x34y34hrd; y34 -> x34y34hrd; x34y34hrd [label="AND", shape=box]; x34y34hrd -> hrd
+  ssf -> ssfhqrz19; hqr -> ssfhqrz19; ssfhqrz19 [label="XOR", shape=diamond]; ssfhqrz19 -> z19
+  y37 -> y37x37z37; x37 -> y37x37z37; y37x37z37 [label="AND", shape=box]; y37x37z37 -> z37
+  y04 -> y04x04dgw; x04 -> y04x04dgw; y04x04dgw [label="AND", shape=box]; y04x04dgw -> dgw
+  qft -> qfttwjqpn; twj -> qfttwjqpn; qfttwjqpn [label="AND", shape=box]; qfttwjqpn -> qpn
+  tnn -> tnnbssz16; bss -> tnnbssz16; tnnbssz16 [label="OR", shape=doubleoctagon]; tnnbssz16 -> z16C
+  x12 -> x12y12ppp; y12 -> x12y12ppp; x12y12ppp [label="AND", shape=box]; x12y12ppp -> ppp
+  kmf -> kmfcdbqnf; cdb -> kmfcdbqnf; kmfcdbqnf [label="OR", shape=doubleoctagon]; kmfcdbqnf -> qnfC
+  vsq -> vsqjrgz38; jrg -> vsqjrgz38; vsqjrgz38 [label="XOR", shape=diamond]; vsqjrgz38 -> z38
+  ccs -> ccsrsjz29; rsj -> ccsrsjz29; ccsrsjz29 [label="XOR", shape=diamond]; ccsrsjz29 -> z29
+  y01 -> y01x01jnj; x01 -> y01x01jnj; y01x01jnj [label="XOR", shape=diamond]; y01x01jnj -> jnj
+  mtb -> mtbjdkz04; jdk -> mtbjdkz04; mtbjdkz04 [label="XOR", shape=diamond]; mtbjdkz04 -> z04
+  y21 -> y21x21rqf; x21 -> y21x21rqf; y21x21rqf [label="AND", shape=box]; y21x21rqf -> rqf
+  hnq -> hnqdwdz18; dwd -> hnqdwdz18; hnqdwdz18 [label="XOR", shape=diamond]; hnqdwdz18 -> z18
+  x19 -> x19y19ssf; y19 -> x19y19ssf; x19y19ssf [label="XOR", shape=diamond]; x19y19ssf -> ssf
+  y34 -> y34x34hnk; x34 -> y34x34hnk; y34x34hnk [label="XOR", shape=diamond]; y34x34hnk -> hnk
+  shp -> shpkcppkv; kcp -> shpkcppkv; shpkcppkv [label="AND", shape=box]; shpkcppkv -> pkv
+  x08 -> x08y08twj; y08 -> x08y08twj; x08y08twj [label="XOR", shape=diamond]; x08y08twj -> twj
+  fvc -> fvcpkvthm; pkv -> fvcpkvthm; fvcpkvthm [label="OR", shape=doubleoctagon]; fvcpkvthm -> thmC
+  x41 -> x41y41gtv; y41 -> x41y41gtv; x41y41gtv [label="AND", shape=box]; x41y41gtv -> gtv
+  x06 -> x06y06qmr; y06 -> x06y06qmr; x06y06qmr [label="AND", shape=box]; x06y06qmr -> qmr
+  qsj -> qsjtjkz31; tjk -> qsjtjkz31; qsjtjkz31 [label="AND", shape=box]; qsjtjkz31 -> z31
+  vhj -> vhjrrnjrg; rrn -> vhjrrnjrg; vhjrrnjrg [label="OR", shape=doubleoctagon]; vhjrrnjrg -> jrgC
+  jrg -> jrgvsqtkt; vsq -> jrgvsqtkt; jrgvsqtkt [label="AND", shape=box]; jrgvsqtkt -> tkt
+  y15 -> y15x15svk; x15 -> y15x15svk; y15x15svk [label="AND", shape=box]; y15x15svk -> svk
+  prt -> prtjnjz01; jnj -> prtjnjz01; prtjnjz01 [label="XOR", shape=diamond]; prtjnjz01 -> z01
+  shb -> shbdbdcjt; dbd -> shbdbdcjt; shbdbdcjt [label="AND", shape=box]; shbdbdcjt -> cjt
+  hbc -> hbcqstvhv; qst -> hbcqstvhv; hbcqstvhv [label="AND", shape=box]; hbcqstvhv -> vhv
+  x10 -> x10y10vsm; y10 -> x10y10vsm; x10y10vsm [label="AND", shape=box]; x10y10vsm -> vsm
+  bkp -> bkpvmfz10; vmf -> bkpvmfz10; bkpvmfz10 [label="XOR", shape=diamond]; bkpvmfz10 -> z10
+  y33 -> y33x33sfs; x33 -> y33x33sfs; y33x33sfs [label="AND", shape=box]; y33x33sfs -> sfs
+  kgn -> kgnpgqz14; pgq -> kgnpgqz14; kgnpgqz14 [label="XOR", shape=diamond]; kgnpgqz14 -> z14
+  y36 -> y36x36fjn; x36 -> y36x36fjn; y36x36fjn [label="AND", shape=box]; y36x36fjn -> fjn
+  x00 -> x00y00z00; y00 -> x00y00z00; x00y00z00 [label="XOR", shape=diamond]; x00y00z00 -> z00
+  y40 -> y40x40wqg; x40 -> y40x40wqg; y40x40wqg [label="XOR", shape=diamond]; y40x40wqg -> wqg
+  vsm -> vsmrjwvnw; rjw -> vsmrjwvnw; vsmrjwvnw [label="OR", shape=doubleoctagon]; vsmrjwvnw -> vnwC
+  y42 -> y42x42kcp; x42 -> y42x42kcp; y42x42kcp [label="XOR", shape=diamond]; y42x42kcp -> kcp
+  y29 -> y29x29knv; x29 -> y29x29knv; y29x29knv [label="AND", shape=box]; y29x29knv -> knv
+  nbm -> nbmgcgvhj; gcg -> nbmgcgvhj; nbmgcgvhj [label="AND", shape=box]; nbmgcgvhj -> vhj
+  y13 -> y13x13cpr; x13 -> y13x13cpr; y13x13cpr [label="AND", shape=box]; y13x13cpr -> cpr
+  y32 -> y32x32scw; x32 -> y32x32scw; y32x32scw [label="AND", shape=box]; y32x32scw -> scw
+  dgr -> dgrvncjrk; vnc -> dgrvncjrk; dgrvncjrk [label="AND", shape=box]; dgrvncjrk -> jrk
+  thm -> thmdnfz43; dnf -> thmdnfz43; thmdnfz43 [label="XOR", shape=diamond]; thmdnfz43 -> z43
+  bgj -> bgjchbqsj; chb -> bgjchbqsj; bgjchbqsj [label="OR", shape=doubleoctagon]; bgjchbqsj -> qsjC
+  qsj -> qsjtjkrdn; tjk -> qsjtjkrdn; qsjtjkrdn [label="XOR", shape=diamond]; qsjtjkrdn -> rdn
+  thq -> thqknvrbk; knv -> thqknvrbk; thqknvrbk [label="OR", shape=doubleoctagon]; thqknvrbk -> rbkC
+  sqr -> sqrnjbsmh; njb -> sqrnjbsmh; sqrnjbsmh [label="AND", shape=box]; sqrnjbsmh -> smh
+  x15 -> x15y15shb; y15 -> x15y15shb; x15y15shb [label="XOR", shape=diamond]; x15y15shb -> shb
+  qfv -> qfvqcmrcm; qcm -> qfvqcmrcm; qfvqcmrcm [label="OR", shape=doubleoctagon]; qfvqcmrcm -> rcmC
+  x25 -> x25y25rhk; y25 -> x25y25rhk; x25y25rhk [label="XOR", shape=diamond]; x25y25rhk -> rhk
+  y31 -> y31x31tjk; x31 -> y31x31tjk; y31x31tjk [label="XOR", shape=diamond]; y31x31tjk -> tjk
+  rdn -> rdnpctvtb; pct -> rdnpctvtb; rdnpctvtb [label="OR", shape=doubleoctagon]; rdnpctvtb -> vtbC
+  sqr -> sqrnjbz20; njb -> sqrnjbz20; sqrnjbz20 [label="XOR", shape=diamond]; sqrnjbz20 -> z20
+  fjc -> fjcrcmz27; rcm -> fjcrcmz27; fjcrcmz27 [label="XOR", shape=diamond]; fjcrcmz27 -> z27
+  x42 -> x42y42fvc; y42 -> x42y42fvc; x42y42fvc [label="AND", shape=box]; x42y42fvc -> fvc
+  y14 -> y14x14qtq; x14 -> y14x14qtq; y14x14qtq [label="AND", shape=box]; y14x14qtq -> qtq
+  x36 -> x36y36ckw; y36 -> x36y36ckw; x36y36ckw [label="XOR", shape=diamond]; x36y36ckw -> ckw
+  y39 -> y39x39gkk; x39 -> y39x39gkk; y39x39gkk [label="XOR", shape=diamond]; y39x39gkk -> gkk
+  gtv -> gtvjhdshp; jhd -> gtvjhdshp; gtvjhdshp [label="OR", shape=doubleoctagon]; gtvjhdshp -> shpC
+  x38 -> x38y38knb; y38 -> x38y38knb; x38y38knb [label="AND", shape=box]; x38y38knb -> knb
+  kgn -> kgnpgqrhw; pgq -> kgnpgqrhw; kgnpgqrhw [label="AND", shape=box]; kgnpgqrhw -> rhw
+  sfw -> sfwjckqpk; jck -> sfwjckqpk; sfwjckqpk [label="AND", shape=box]; sfwjckqpk -> qpk
+  pwb -> pwbjdqz35; jdq -> pwbjdqz35; pwbjdqz35 [label="XOR", shape=diamond]; pwbjdqz35 -> z35
+  y05 -> y05x05rqw; x05 -> y05x05rqw; y05x05rqw [label="XOR", shape=diamond]; y05x05rqw -> rqw
+  x23 -> x23y23crt; y23 -> x23y23crt; x23y23crt [label="XOR", shape=diamond]; x23y23crt -> crt
+  x09 -> x09y09jtc; y09 -> x09y09jtc; x09y09jtc [label="XOR", shape=diamond]; x09y09jtc -> jtc
+  ksh -> kshkccz06; kcc -> kshkccz06; kshkccz06 [label="XOR", shape=diamond]; kshkccz06 -> z06
+  hnv -> hnvmcjqcm; mcj -> hnvmcjqcm; hnvmcjqcm [label="AND", shape=box]; hnvmcjqcm -> qcm
+  y17 -> y17x17rcc; x17 -> y17x17rcc; y17x17rcc [label="XOR", shape=diamond]; y17x17rcc -> rcc
+  y23 -> y23x23nbr; x23 -> y23x23nbr; y23x23nbr [label="AND", shape=box]; y23x23nbr -> nbr
+  bqm -> bqmqpnvrr; qpn -> bqmqpnvrr; bqmqpnvrr [label="OR", shape=doubleoctagon]; bqmqpnvrr -> vrrC
+  fpv -> fpvsmhhvv; smh -> fpvsmhhvv; fpvsmhhvv [label="OR", shape=doubleoctagon]; fpvsmhhvv -> hvvC
+  swq -> swqpdbnjb; pdb -> swqpdbnjb; swqpdbnjb [label="OR", shape=doubleoctagon]; swqpdbnjb -> njbC
+  x13 -> x13y13dgr; y13 -> x13y13dgr; x13y13dgr [label="XOR", shape=diamond]; x13y13dgr -> dgr
+  jnj -> jnjprtcdb; prt -> jnjprtcdb; jnjprtcdb [label="AND", shape=box]; jnjprtcdb -> cdb
+  x10 -> x10y10vmf; y10 -> x10y10vmf; x10y10vmf [label="XOR", shape=diamond]; x10y10vmf -> vmf
+  y37 -> y37x37gcg; x37 -> y37x37gcg; y37x37gcg [label="XOR", shape=diamond]; y37x37gcg -> gcg
+  x21 -> x21y21nnr; y21 -> x21y21nnr; x21y21nnr [label="XOR", shape=diamond]; x21y21nnr -> nnr
+  qst -> qsthbcz24; hbc -> qsthbcz24; qsthbcz24 [label="XOR", shape=diamond]; qsthbcz24 -> z24
+  rcm -> rcmfjcpfb; fjc -> rcmfjcpfb; rcmfjcpfb [label="AND", shape=box]; rcmfjcpfb -> pfb
+  y18 -> y18x18pnv; x18 -> y18x18pnv; y18x18pnv [label="AND", shape=box]; y18x18pnv -> pnv
+  wqg -> wqggggfvv; ggg -> wqggggfvv; wqggggfvv [label="AND", shape=box]; wqggggfvv -> fvv
+  mcj -> mcjhnvz26; hnv -> mcjhnvz26; mcjhnvz26 [label="XOR", shape=diamond]; mcjhnvz26 -> z26
+  dwd -> dwdhnqcdt; hnq -> dwdhnqcdt; dwdhnqcdt [label="AND", shape=box]; dwdhnqcdt -> cdt
+  wsm -> wsmqnfz02; qnf -> wsmqnfz02; wsmqnfz02 [label="XOR", shape=diamond]; wsmqnfz02 -> z02
+  vnm -> vnmmgrz03; mgr -> vnmmgrz03; vnmmgrz03 [label="XOR", shape=diamond]; vnmmgrz03 -> z03
+  sfw -> sfwjckz22; jck -> sfwjckz22; sfwjckz22 [label="XOR", shape=diamond]; sfwjckz22 -> z22
+  x08 -> x08y08bqm; y08 -> x08y08bqm; x08y08bqm [label="AND", shape=box]; x08y08bqm -> bqm
+  qmr -> qmrfjtdrd; fjt -> qmrfjtdrd; qmrfjtdrd [label="OR", shape=doubleoctagon]; qmrfjtdrd -> drdC
+  cdt -> cdtpnvhqr; pnv -> cdtpnvhqr; cdtpnvhqr [label="OR", shape=doubleoctagon]; cdtpnvhqr -> hqrC
+  ksh -> kshkccfjt; kcc -> kshkccfjt; kshkccfjt [label="AND", shape=box]; kshkccfjt -> fjt
+  wqt -> wqtktnqft; ktn -> wqtktnqft; wqtktnqft [label="OR", shape=doubleoctagon]; wqtktnqft -> qftC
+  y24 -> y24x24cbh; x24 -> y24x24cbh; y24x24cbh [label="AND", shape=box]; y24x24cbh -> cbh
+  x00 -> x00y00prt; y00 -> x00y00prt; x00y00prt [label="AND", shape=box]; x00y00prt -> prt
+  dgr -> dgrvncz13; vnc -> dgrvncz13; dgrvncz13 [label="XOR", shape=diamond]; dgrvncz13 -> z13
+  vrr -> vrrjtcz09; jtc -> vrrjtcz09; vrrjtcz09 [label="XOR", shape=diamond]; vrrjtcz09 -> z09
+  fmr -> fmrdgwjtm; dgw -> fmrdgwjtm; fmrdgwjtm [label="OR", shape=doubleoctagon]; fmrdgwjtm -> jtmC
+  jnr -> jnrrbkchb; rbk -> jnrrbkchb; jnrrbkchb [label="AND", shape=box]; jnrrbkchb -> chb
+  rqf -> rqfhvvjsd; hvv -> rqfhvvjsd; rqfhvvjsd [label="AND", shape=box]; rqfhvvjsd -> jsd
+  x11 -> x11y11qmm; y11 -> x11y11qmm; x11y11qmm [label="AND", shape=box]; x11y11qmm -> qmm
+  y31 -> y31x31pct; x31 -> y31x31pct; y31x31pct [label="AND", shape=box]; y31x31pct -> pct
+  jrf -> jrfshrvnm; shr -> jrfshrvnm; jrfshrvnm [label="OR", shape=doubleoctagon]; jrfshrvnm -> vnmC
+  ckw -> ckwmcvcrk; mcv -> ckwmcvcrk; ckwmcvcrk [label="AND", shape=box]; ckwmcvcrk -> crk
+  x43 -> x43y43pss; y43 -> x43y43pss; x43y43pss [label="AND", shape=box]; x43y43pss -> pss
+  jnr -> jnrrbkz30; rbk -> jnrrbkz30; jnrrbkz30 [label="XOR", shape=diamond]; jnrrbkz30 -> z30
+  x20 -> x20y20fpv; y20 -> x20y20fpv; x20y20fpv [label="AND", shape=box]; x20y20fpv -> fpv
+  ntw -> ntwfvvtph; fvv -> ntwfvvtph; ntwfvvtph [label="OR", shape=doubleoctagon]; ntwfvvtph -> tphC
+  x14 -> x14y14pgq; y14 -> x14y14pgq; x14y14pgq [label="XOR", shape=diamond]; x14y14pgq -> pgq
+  tph -> tphhbkz41; hbk -> tphhbkz41; tphhbkz41 [label="XOR", shape=diamond]; tphhbkz41 -> z41
+  nbr -> nbrsppqst; spp -> nbrsppqst; nbrsppqst [label="OR", shape=doubleoctagon]; nbrsppqst -> qstC
+  ckw -> ckwmcvz36; mcv -> ckwmcvz36; ckwmcvz36 [label="XOR", shape=diamond]; ckwmcvz36 -> z36
+  pps -> ppsphcjdk; phc -> ppsphcjdk; ppsphcjdk [label="OR", shape=doubleoctagon]; ppsphcjdk -> jdkC
+  vrr -> vrrjtchwp; jtc -> vrrjtchwp; vrrjtchwp [label="AND", shape=box]; vrrjtchwp -> hwp
+  jdq -> jdqpwbwdv; pwb -> jdqpwbwdv; jdqpwbwdv [label="AND", shape=box]; jdqpwbwdv -> wdv
+  y20 -> y20x20sqr; x20 -> y20x20sqr; y20x20sqr [label="XOR", shape=diamond]; y20x20sqr -> sqr
+  crk -> crkfjnnbm; fjn -> crkfjnnbm; crkfjnnbm [label="OR", shape=doubleoctagon]; crkfjnnbm -> nbmC
+  hwp -> hwpnwnbkp; nwn -> hwpnwnbkp; hwpnwnbkp [label="OR", shape=doubleoctagon]; hwpnwnbkp -> bkpC
+  wsm -> wsmqnfshr; qnf -> wsmqnfshr; wsmqnfshr [label="AND", shape=box]; wsmqnfshr -> shr
+  x26 -> x26y26qfv; y26 -> x26y26qfv; x26y26qfv [label="AND", shape=box]; x26y26qfv -> qfv
+  y26 -> y26x26mcj; x26 -> y26x26mcj; y26x26mcj [label="XOR", shape=diamond]; y26x26mcj -> mcj
+  crt -> crtnknz23; nkn -> crtnknz23; crtnknz23 [label="XOR", shape=diamond]; crtnknz23 -> z23
+  ncp -> ncpdrdz07; drd -> ncpdrdz07; ncpdrdz07 [label="XOR", shape=diamond]; ncpdrdz07 -> z07
+  vtb -> vtbdfnrdg; dfn -> vtbdfnrdg; vtbdfnrdg [label="AND", shape=box]; vtbdfnrdg -> rdg
+  wqg -> wqggggz40; ggg -> wqggggz40; wqggggz40 [label="XOR", shape=diamond]; wqggggz40 -> z40
+  x27 -> x27y27fjc; y27 -> x27y27fjc; x27y27fjc [label="XOR", shape=diamond]; x27y27fjc -> fjc
+  fkb -> fkbrccz17; rcc -> fkbrccz17; fkbrccz17 [label="XOR", shape=diamond]; fkbrccz17 -> z17
+  vtb -> vtbdfnz32; dfn -> vtbdfnz32; vtbdfnz32 [label="XOR", shape=diamond]; vtbdfnz32 -> z32
+  rqw -> rqwjtmz05; jtm -> rqwjtmz05; rqwjtmz05 [label="XOR", shape=diamond]; rqwjtmz05 -> z05
+  kcp -> kcpshpz42; shp -> kcpshpz42; kcpshpz42 [label="XOR", shape=diamond]; kcpshpz42 -> z42
+  hrd -> hrdtdbpwb; tdb -> hrdtdbpwb; hrdtdbpwb [label="OR", shape=doubleoctagon]; hrdtdbpwb -> pwbC
+  x35 -> x35y35qph; y35 -> x35y35qph; x35y35qph [label="AND", shape=box]; x35y35qph -> qph
+  y22 -> y22x22btq; x22 -> y22x22btq; y22x22btq [label="AND", shape=box]; y22x22btq -> btq
+  tkt -> tktknbcrp; knb -> tktknbcrp; tktknbcrp [label="OR", shape=doubleoctagon]; tktknbcrp -> crpC
+  y03 -> y03x03pps; x03 -> y03x03pps; y03x03pps [label="AND", shape=box]; y03x03pps -> pps
+  x41 -> x41y41hbk; y41 -> x41y41hbk; x41y41hbk [label="XOR", shape=diamond]; x41y41hbk -> hbk
+  x25 -> x25y25smj; y25 -> x25y25smj; x25y25smj [label="AND", shape=box]; x25y25smj -> smj
+  dnf -> dnfthmwrt; thm -> dnfthmwrt; dnfthmwrt [label="AND", shape=box]; dnfthmwrt -> wrt
+  y02 -> y02x02wsm; x02 -> y02x02wsm; y02x02wsm [label="XOR", shape=diamond]; y02x02wsm -> wsm
+  y07 -> y07x07wqt; x07 -> y07x07wqt; y07x07wqt [label="AND", shape=box]; y07x07wqt -> wqt
+  dbg -> dbgbcqz12; bcq -> dbgbcqz12; dbgbcqz12 [label="XOR", shape=diamond]; dbgbcqz12 -> z12
+  y24 -> y24x24hbc; x24 -> y24x24hbc; y24x24hbc [label="XOR", shape=diamond]; y24x24hbc -> hbc
+  nkn -> nkncrtspp; crt -> nkncrtspp; nkncrtspp [label="AND", shape=box]; nkncrtspp -> spp
+  qtq -> qtqrhwdbd; rhw -> qtqrhwdbd; qtqrhwdbd [label="OR", shape=doubleoctagon]; qtqrhwdbd -> dbdC
+  jsd -> jsdnnrsfw; nnr -> jsdnnrsfw; jsdnnrsfw [label="OR", shape=doubleoctagon]; jsdnnrsfw -> sfwC
+}
+

day24/input.txt

@@ -0,0 +1,313 @@
+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: 1
+x14: 1
+x15: 0
+x16: 0
+x17: 1
+x18: 0
+x19: 0
+x20: 0
+x21: 0
+x22: 0
+x23: 1
+x24: 0
+x25: 0
+x26: 1
+x27: 1
+x28: 0
+x29: 1
+x30: 1
+x31: 0
+x32: 0
+x33: 0
+x34: 0
+x35: 1
+x36: 0
+x37: 1
+x38: 1
+x39: 0
+x40: 1
+x41: 0
+x42: 1
+x43: 0
+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: 0
+y14: 1
+y15: 1
+y16: 1
+y17: 0
+y18: 1
+y19: 0
+y20: 1
+y21: 0
+y22: 1
+y23: 0
+y24: 0
+y25: 0
+y26: 0
+y27: 1
+y28: 1
+y29: 0
+y30: 1
+y31: 1
+y32: 1
+y33: 1
+y34: 1
+y35: 0
+y36: 1
+y37: 1
+y38: 0
+y39: 0
+y40: 1
+y41: 1
+y42: 0
+y43: 1
+y44: 1
+
+y16 AND x16 -> bss
+wrt OR pss -> fjs
+qpd AND hnk -> tdb
+ncp AND drd -> ktn
+vnw AND ftq -> kgt
+y12 XOR x12 -> dbg
+y05 AND x05 -> jfq
+x16 XOR y16 -> grr
+y39 AND x39 -> tbr
+crp AND gkk -> qkk
+x02 AND y02 -> jrf
+x09 AND y09 -> nwn
+vmf AND bkp -> rjw
+qpd XOR hnk -> z34
+x06 XOR y06 -> kcc
+x30 AND y30 -> bgj
+rhk AND btv -> rmv
+fjs XOR bmv -> z44
+btv XOR rhk -> z25
+wgk OR ppp -> vnc
+kcm XOR grr -> z16
+fkb AND rcc -> fbb
+dbd XOR shb -> z15
+y38 XOR x38 -> vsq
+sfs OR hmh -> qpd
+bmv AND fjs -> kwh
+ftq XOR vnw -> z11
+cjt OR svk -> kcm
+y33 XOR x33 -> ttn
+x18 XOR y18 -> dwd
+qpk OR btq -> nkn
+nnq OR pfb -> mfc
+crp XOR gkk -> z39
+x28 AND y28 -> dwg
+y07 XOR x07 -> ncp
+ssf AND hqr -> swq
+mfc AND hdk -> pqk
+y44 XOR x44 -> bmv
+x35 XOR y35 -> jdq
+y30 XOR x30 -> jnr
+x32 XOR y32 -> dfn
+ccw OR fbb -> hnq
+pqk OR dwg -> rsj
+jrk OR cpr -> kgn
+x01 AND y01 -> kmf
+kcm AND grr -> tnn
+y28 XOR x28 -> hdk
+mtb AND jdk -> fmr
+y29 XOR x29 -> ccs
+vhv OR cbh -> btv
+hdk XOR mfc -> z28
+dbg AND bcq -> wgk
+x11 XOR y11 -> ftq
+y04 XOR x04 -> mtb
+vnm AND mgr -> phc
+jfq OR tsw -> ksh
+gcg XOR nbm -> z37
+wdv OR qph -> mcv
+x19 AND y19 -> pdb
+rqf XOR hvv -> z21
+y27 AND x27 -> nnq
+rdg OR scw -> jmt
+qkk OR tbr -> ggg
+jtm AND rqw -> tsw
+ccs AND rsj -> thq
+kgt OR qmm -> bcq
+kwh OR qqr -> z45
+twj XOR qft -> z08
+ttn AND jmt -> hmh
+y44 AND x44 -> qqr
+x03 XOR y03 -> mgr
+x40 AND y40 -> ntw
+jmt XOR ttn -> z33
+x43 XOR y43 -> dnf
+rmv OR smj -> hnv
+y17 AND x17 -> ccw
+y22 XOR x22 -> jck
+tph AND hbk -> jhd
+x34 AND y34 -> hrd
+ssf XOR hqr -> z19
+y37 AND x37 -> rrn
+y04 AND x04 -> dgw
+qft AND twj -> qpn
+tnn OR bss -> fkb
+x12 AND y12 -> ppp
+kmf OR cdb -> qnf
+vsq XOR jrg -> z38
+ccs XOR rsj -> z29
+y01 XOR x01 -> jnj
+mtb XOR jdk -> z04
+y21 AND x21 -> nnr
+hnq XOR dwd -> z18
+x19 XOR y19 -> ssf
+y34 XOR x34 -> hnk
+shp AND kcp -> pkv
+x08 XOR y08 -> twj
+fvc OR pkv -> thm
+x41 AND y41 -> gtv
+x06 AND y06 -> qmr
+qsj AND tjk -> rdn
+vhj OR rrn -> jrg
+jrg AND vsq -> tkt
+y15 AND x15 -> svk
+prt XOR jnj -> z01
+shb AND dbd -> cjt
+hbc AND qst -> vhv
+x10 AND y10 -> vsm
+bkp XOR vmf -> z10
+y33 AND x33 -> sfs
+kgn XOR pgq -> z14
+y36 AND x36 -> fjn
+x00 XOR y00 -> z00
+y40 XOR x40 -> wqg
+vsm OR rjw -> vnw
+y42 XOR x42 -> kcp
+y29 AND x29 -> knv
+nbm AND gcg -> vhj
+y13 AND x13 -> cpr
+y32 AND x32 -> scw
+dgr AND vnc -> jrk
+thm XOR dnf -> z43
+bgj OR chb -> qsj
+qsj XOR tjk -> z31
+thq OR knv -> rbk
+sqr AND njb -> smh
+x15 XOR y15 -> shb
+qfv OR qcm -> rcm
+x25 XOR y25 -> rhk
+y31 XOR x31 -> tjk
+rdn OR pct -> vtb
+sqr XOR njb -> z20
+fjc XOR rcm -> z27
+x42 AND y42 -> fvc
+y14 AND x14 -> qtq
+x36 XOR y36 -> ckw
+y39 XOR x39 -> gkk
+gtv OR jhd -> shp
+x38 AND y38 -> knb
+kgn AND pgq -> rhw
+sfw AND jck -> qpk
+pwb XOR jdq -> z35
+y05 XOR x05 -> rqw
+x23 XOR y23 -> crt
+x09 XOR y09 -> jtc
+ksh XOR kcc -> z06
+hnv AND mcj -> qcm
+y17 XOR x17 -> rcc
+y23 AND x23 -> nbr
+bqm OR qpn -> vrr
+fpv OR smh -> hvv
+swq OR pdb -> njb
+x13 XOR y13 -> dgr
+jnj AND prt -> cdb
+x10 XOR y10 -> vmf
+y37 XOR x37 -> gcg
+x21 XOR y21 -> rqf
+qst XOR hbc -> z24
+rcm AND fjc -> pfb
+y18 AND x18 -> pnv
+wqg AND ggg -> fvv
+mcj XOR hnv -> z26
+dwd AND hnq -> cdt
+wsm XOR qnf -> z02
+vnm XOR mgr -> z03
+sfw XOR jck -> z22
+x08 AND y08 -> bqm
+qmr OR fjt -> drd
+cdt OR pnv -> hqr
+ksh AND kcc -> fjt
+wqt OR ktn -> qft
+y24 AND x24 -> cbh
+x00 AND y00 -> prt
+dgr XOR vnc -> z13
+vrr XOR jtc -> z09
+fmr OR dgw -> jtm
+jnr AND rbk -> chb
+rqf AND hvv -> jsd
+x11 AND y11 -> qmm
+y31 AND x31 -> pct
+jrf OR shr -> vnm
+ckw AND mcv -> crk
+x43 AND y43 -> pss
+jnr XOR rbk -> z30
+x20 AND y20 -> fpv
+ntw OR fvv -> tph
+x14 XOR y14 -> pgq
+tph XOR hbk -> z41
+nbr OR spp -> qst
+ckw XOR mcv -> z36
+pps OR phc -> jdk
+vrr AND jtc -> hwp
+jdq AND pwb -> wdv
+y20 XOR x20 -> sqr
+crk OR fjn -> nbm
+hwp OR nwn -> bkp
+wsm AND qnf -> shr
+x26 AND y26 -> qfv
+y26 XOR x26 -> mcj
+crt XOR nkn -> z23
+ncp XOR drd -> z07
+vtb AND dfn -> rdg
+wqg XOR ggg -> z40
+x27 XOR y27 -> fjc
+fkb XOR rcc -> z17
+vtb XOR dfn -> z32
+rqw XOR jtm -> z05
+kcp XOR shp -> z42
+hrd OR tdb -> pwb
+x35 AND y35 -> qph
+y22 AND x22 -> btq
+tkt OR knb -> crp
+y03 AND x03 -> pps
+x41 XOR y41 -> hbk
+x25 AND y25 -> smj
+dnf AND thm -> wrt
+y02 XOR x02 -> wsm
+y07 AND x07 -> wqt
+dbg XOR bcq -> z12
+y24 XOR x24 -> hbc
+nkn AND crt -> spp
+qtq OR rhw -> dbd
+jsd OR nnr -> sfw

day24/test0.txt

@@ -0,0 +1,10 @@
+x00: 1
+x01: 1
+x02: 1
+y00: 0
+y01: 1
+y02: 0
+
+x00 AND y00 -> z00
+x01 XOR y01 -> z01
+x02 OR y02 -> z02

day24/test1.txt

@@ -0,0 +1,47 @@
+x00: 1
+x01: 0
+x02: 1
+x03: 1
+x04: 0
+y00: 1
+y01: 1
+y02: 1
+y03: 1
+y04: 1
+
+ntg XOR fgs -> mjb
+y02 OR x01 -> tnw
+kwq OR kpj -> z05
+x00 OR x03 -> fst
+tgd XOR rvg -> z01
+vdt OR tnw -> bfw
+bfw AND frj -> z10
+ffh OR nrd -> bqk
+y00 AND y03 -> djm
+y03 OR y00 -> psh
+bqk OR frj -> z08
+tnw OR fst -> frj
+gnj AND tgd -> z11
+bfw XOR mjb -> z00
+x03 OR x00 -> vdt
+gnj AND wpb -> z02
+x04 AND y00 -> kjc
+djm OR pbm -> qhw
+nrd AND vdt -> hwm
+kjc AND fst -> rvg
+y04 OR y02 -> fgs
+y01 AND x02 -> pbm
+ntg OR kjc -> kwq
+psh XOR fgs -> tgd
+qhw XOR tgd -> z09
+pbm OR djm -> kpj
+x03 XOR y03 -> ffh
+x00 XOR y04 -> ntg
+bfw OR bqk -> z06
+nrd XOR fgs -> wpb
+frj XOR qhw -> z04
+bqk OR frj -> z07
+y03 OR x01 -> nrd
+hwm AND bqk -> z03
+tgd XOR rvg -> z12
+tnw OR pbm -> gnj

day25/d25p1.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+struct Key : CustomStringConvertible {
+    let pins: [Int]
+    var description: String {
+        return "(" + pins.map(String.init).joined(separator: ",") + ")"
+    }
+    init(_ block: ArraySlice<[Character]>) {
+        var pins: [Int] = [0, 0, 0, 0, 0]
+        ((block.startIndex+1)..<(block.endIndex-1)).forEach { i in
+            for j in 0..<5 {
+                if pins[j] == 0 && block[i][j] == "#" {
+                    pins[j] = 6 - (i - block.startIndex)
+                }
+            }
+        }
+        self.pins = pins
+    }
+}
+
+struct Lock : CustomStringConvertible { 
+    let pins: [Int]
+    var description: String {
+        return "(" + pins.map(String.init).joined(separator: ",") + ")"
+    }
+    init(_ block: ArraySlice<[Character]>) {
+        var pins: [Int] = [0, 0, 0, 0, 0]
+        ((block.startIndex+1)..<(block.endIndex-1)).reversed().forEach { i in
+            for j in 0..<5 {
+                if pins[j] == 0 && block[i][j] == "#" {
+                    pins[j] = i - block.startIndex
+                }
+            }
+        }
+        self.pins = pins
+    }
+}
+
+func readInput(_ filePath: String) throws -> ([Lock], [Key]) {
+    let content = try String(contentsOfFile: filePath, encoding: .ascii)
+    let lines = content.split(separator: "\n", omittingEmptySubsequences: false)
+    var locks: [Lock] = []
+    var keys: [Key] = []
+    lines.map(Array.init).split(separator: []).forEach { block in
+        if block[block.startIndex][0] == "#" {
+            locks.append(Lock(block))
+        } else {
+            keys.append(Key(block))
+        }
+    }
+    return (locks, keys)
+}
+
+let (locks, keys) = try readInput(CommandLine.arguments[1])
+var answer = 0
+for lock in locks {
+    for key in keys {
+        answer += zip(lock.pins, key.pins).contains { $0 + $1 > 5 } ? 0 : 1
+    }
+}
+print(answer)
+

day25/test.txt

@@ -0,0 +1,39 @@
+#####
+.####
+.####
+.####
+.#.#.
+.#...
+.....
+
+#####
+##.##
+.#.##
+...##
+...#.
+...#.
+.....
+
+.....
+#....
+#....
+#...#
+#.#.#
+#.###
+#####
+
+.....
+.....
+#.#..
+###..
+###.#
+###.#
+#####
+
+.....
+.....
+.....
+#....
+#.#..
+#.#.#
+#####