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

//! # Day 12: Leonardo's Monorail
//!
//! You finally reach the top floor of this building: a garden with a slanted glass ceiling. Looks
//! like there are no more stars to be had.
//!
//! While sitting on a nearby bench amidst some [tiger lilies], you manage to decrypt some of the
//! files you extracted from the servers downstairs.
//!
//! According to these documents, Easter Bunny HQ isn't just this building - it's a collection of
//! buildings in the nearby area. They're all connected by a local monorail, and there's another
//! building not far from here! Unfortunately, being night, the monorail is currently not operating.
//!
//! You remotely connect to the monorail control systems and discover that the boot sequence expects
//! a password. The password-checking logic (your puzzle input) is easy to extract, but the code it
//! uses is strange: it's assembunny code designed for the [new computer] you just assembled. You'll
//! have to execute the code and get the password.
//!
//! The assembunny code you've extracted operates on four [registers] (`a`, `b`, `c`, and `d`) that
//! start at 0 and can hold any [integer]. However, it seems to make use of only a few
//! [instructions]:
//!
//! - `cpy x y` **copies** `x` (either an integer or the **value** of a register) into register `y`.
//! - `inc x` **increases** the value of register `x` by one.
//! - `dec x` **decreases** the value of register `x` by one.
//! - `jnz x y` **jumps** to an instruction `y` away (positive means forward; negative means
//!   backward), but only if `x` is **not zero**.
//!
//! The `jnz` instruction moves relative to itself: an offset of `-1` would continue at the previous
//! instruction, while an offset of `2` would **skip over** the next instruction.
//!
//! For example:
//!
//! ```txt
//! cpy 41 a
//! inc a
//! inc a
//! dec a
//! jnz a 2
//! dec a
//! ```
//!
//! The above code would set register `a` to `41`, increase its value by `2`, decrease its value by
//! `1`, and then skip the last `dec a` (because `a` is not zero, so the `jnz a 2` skips it),
//! leaving register `a` at `42`. When you move past the last instruction, the program halts.
//!
//! After executing the assembunny code in your puzzle input, **what value is left in register
//! `a`?**
//!
//! [tiger lilies]: https://www.google.com/search?q=tiger+lilies&tbm=isch
//! [new computer]: super::d11
//! [registers]: https://en.wikipedia.org/wiki/Processor_register
//! [integer]: https://en.wikipedia.org/wiki/Integer
//! [instructions]: https://en.wikipedia.org/wiki/Instruction_set

use anyhow::Result;

pub const INPUT: &str = include_str!("d12.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() {}
}