1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! # Day 7: Some Assembly Required
//!
//! This year, Santa brought little Bobby Tables a set of wires and [bitwise logic gates]!
//! Unfortunately, little Bobby is a little under the recommended age range, and he needs help
//! assembling the circuit.
//!
//! Each wire has an identifier (some lowercase letters) and can carry a [16-bit] signal (a number
//! from `0` to `65535`). A signal is provided to each wire by a gate, another wire, or some
//! specific value. Each wire can only get a signal from one source, but can provide its signal to
//! multiple destinations. A gate provides no signal until all of its inputs have a signal.
//!
//! The included instructions booklet describes how to connect the parts together: `x AND y -> z`
//! means to connect wires `x` and `y` to an AND gate, and then connect its output to wire `z`.
//!
//! For example:
//!
//! - `123 -> x` means that the signal `123` is provided to wire `x`.
//! - `x AND y -> z` means that the [bitwise AND] of wire `x` and wire `y` is provided to wire `z`.
//! - `p LSHIFT 2 -> q` means that the value from wire `p` is [left-shifted] by `2` and then
//!   provided to wire `q`.
//! - `NOT e -> f` means that the [bitwise complement] of the value from wire `e` is provided to
//!   wire `f`.
//!
//! Other possible gates include `OR` ([bitwise OR]) and `RSHIFT` ([right-shift]). If, for some
//! reason, you'd like to **emulate** the circuit instead, almost all programming languages (for
//! example, [C], [JavaScript], or [Python]) provide operators for these gates.
//!
//! For example, here is a simple circuit:
//!
//! ```txt
//! 123 -> x
//! 456 -> y
//! x AND y -> d
//! x OR y -> e
//! x LSHIFT 2 -> f
//! y RSHIFT 2 -> g
//! NOT x -> h
//! NOT y -> i
//! ```
//!
//! After it is run, these are the signals on the wires:
//!
//! ```txt
//! d: 72
//! e: 507
//! f: 492
//! g: 114
//! h: 65412
//! i: 65079
//! x: 123
//! y: 456
//! ```
//!
//! In little Bobby's kit's instructions booklet (provided as your puzzle input), what signal is
//! ultimately provided to **wire `a`**?
//!
//! [bitwise logic gates]: https://en.wikipedia.org/wiki/Bitwise_operation
//! [16-bit]: https://en.wikipedia.org/wiki/16-bit
//! [bitwise AND]: https://en.wikipedia.org/wiki/Bitwise_operation#AND
//! [left-shifted]: https://en.wikipedia.org/wiki/Logical_shift
//! [bitwise complement]: https://en.wikipedia.org/wiki/Bitwise_operation#NOT
//! [bitwise OR]: https://en.wikipedia.org/wiki/Bitwise_operation#OR
//! [right-shift]: https://en.wikipedia.org/wiki/Logical_shift
//! [C]: https://en.wikipedia.org/wiki/Bitwise_operations_in_C
//! [JavaScript]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators
//! [Python]: https://wiki.python.org/moin/BitwiseOperators

use anyhow::Result;

pub const INPUT: &str = include_str!("d07.txt");

pub fn solve_part_one(input: &str) -> Result<i64> {
    Ok(0)
}

pub fn solve_part_two(input: &str) -> Result<i64> {
    Ok(0)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn part_one() {}

    #[test]
    fn part_two() {}
}