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 18: Duet
//!
//! You discover a tablet containing some strange assembly code labeled simply "[Duet]". Rather than
//! bother the sound card with it, you decide to run the code yourself. Unfortunately, you don't see
//! any documentation, so you're left to figure out what the instructions mean on your own.
//!
//! It seems like the assembly is meant to operate on a set of **registers** that are each named
//! with a single letter and that can each hold a single [integer]. You suppose each register should
//! start with a value of `0`.
//!
//! There aren't that many instructions, so it shouldn't be hard to figure out what they do. Here's
//! what you determine:
//!
//! - `snd X` **plays a sound** with a frequency equal to the value of `X`.
//! - `set X Y` **sets** register `X` to the value of `Y`.
//! - `add X Y` **increases** register `X` by the value of `Y`.
//! - `mul X Y` sets register `X` to the result of **multiplying** the value contained in register
//!   `X` by the value of `Y`.
//! - `mod X Y` sets register `X` to the **remainder** of dividing the value contained in register
//!   `X` by the value of `Y` (that is, it sets `X` to the result of `X` [modulo] `Y`).
//! - `rcv X` **recovers** the frequency of the last sound played, but only when the value of `X` is
//!   not zero. (If it is zero, the command does nothing.)
//! - `jgz X Y` **jumps** with an offset of the value of `Y`, but only if the value of `X` is
//!   **greater than zero**. (An offset of `2` skips the next instruction, an offset of `-1` jumps
//!   to the previous instruction, and so on.)
//!
//! Many of the instructions can take either a register (a single letter) or a number. The value of
//! a register is the integer it contains; the value of a number is that number.
//!
//! After each **jump** instruction, the program continues with the instruction to which the
//! **jump** jumped. After any other instruction, the program continues with the next instruction.
//! Continuing (or jumping) off either end of the program terminates it.
//!
//! For example:
//!
//! ```txt
//! set a 1
//! add a 2
//! mul a a
//! mod a 5
//! snd a
//! set a 0
//! rcv a
//! jgz a -1
//! set a 1
//! jgz a -2
//! ```
//!
//! - The first four instructions set `a` to `1`, add `2` to it, square it, and then set it to
//!   itself modulo `5`, resulting in a value of `4`.
//! - Then, a sound with frequency `4` (the value of `a`) is played.
//! - After that, `a` is set to `0`, causing the subsequent `rcv` and `jgz` instructions to both be
//!   skipped (`rcv` because `a` is `0`, and `jgz` because `a` is not greater than `0`).
//! - Finally, `a` is set to `1`, causing the next `jgz` instruction to activate, jumping back two
//!   instructions to another jump, which jumps again to the `rcv`, which ultimately triggers the
//!   **recover** operation.
//!
//! At the time the **recover** operation is executed, the frequency of the last sound played is
//! `4`.
//!
//! **What is the value of the recovered frequency** (the value of the most recently played sound)
//! the **first** time a `rcv` instruction is executed with a non-zero value?
//!
//! [Duet]: https://en.wikipedia.org/wiki/Duet
//! [integer]: https://en.wikipedia.org/wiki/Integer
//! [modulo]: https://en.wikipedia.org/wiki/Modulo_operation

use anyhow::Result;

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