diff --git a/src/day21.rs b/src/day21.rs
new file mode 100644
index 0000000..57d7595
--- /dev/null
+++ b/src/day21.rs
@@ -0,0 +1,271 @@
+use crate::util::maps::Direction;
+use std::collections::HashMap;
+
+const DPADS: usize = 25;
+
+pub fn day21() {
+    let sequences: Vec<String> = crate::input(21).lines().map(|l| l.to_string()).collect();
+
+    let mut memo: HashMap<(String, usize), u64> = HashMap::new();
+    fn deeper(s: String, depth: usize, memo: &mut HashMap<(String, usize), u64>) -> u64 {
+        // if this is already in deep lut, return
+        if let Some(&expanded_size) = memo.get(&(s.to_string(), depth)) {
+            return expanded_size;
+        }
+        // if this is two characters at the end, add expanded size to deep lut, and return
+        if depth == 1 {
+            let expanded_size = expand_dpad_string(&s).len() as u64;
+            memo.insert((s, depth), expanded_size);
+            return expanded_size;
+        }
+        // otherwise 1. expand, 2. split into substrings, and 3. recur for each substring
+        let expanded = expand_dpad_string(&s);
+        // 2. get substrings split by A (but including the A characters at the end of each substring)
+        let substrings: Vec<String> = expanded
+            .split_terminator("A")
+            .map(|substring| {
+                let mut substring = substring.to_string();
+                substring.push_str("A");
+                substring
+            })
+            .collect();
+        let mut total: u64 = 0;
+        for substring in substrings {
+            let final_expanded_size = deeper(substring, depth - 1, memo);
+            total += final_expanded_size;
+        }
+        memo.insert((s, depth), total);
+        total
+    }
+
+    let mut complexity: u64 = 0;
+    for sequence in sequences.iter() {
+        let first_dpad_steps = expand_numpad_string(sequence);
+        let length = deeper(first_dpad_steps.clone(), DPADS, &mut memo);
+        let numeric = sequence
+            .chars()
+            .filter(|c| c.is_numeric())
+            .collect::<String>()
+            .parse::<u64>()
+            .unwrap();
+        complexity += length * numeric;
+    }
+
+    println!("Total Complexity: {}", complexity);
+}
+
+fn expand_dpad_string(s: &str) -> String {
+    let sequence: Vec<usize> = s.chars().map(char_to_directional_keypad_index).collect();
+    sequence_to_dpad_steps(
+        &directional_keypad(),
+        sequence,
+        char_to_directional_keypad_index('A'),
+    )
+}
+
+fn expand_numpad_string(s: &str) -> String {
+    let sequence: Vec<usize> = s.chars().map(char_to_numerical_keypad_index).collect();
+    sequence_to_dpad_steps(
+        &numerical_keypad(),
+        sequence,
+        char_to_numerical_keypad_index('A'),
+    )
+}
+
+fn sequence_to_dpad_steps(keypad: &Keypad, sequence: Vec<usize>, start: usize) -> String {
+    let mut sequence = sequence.clone();
+    sequence.insert(0, start);
+
+    let mut total_path = "".to_string();
+
+    for w in sequence.windows(2) {
+        let best_path = shortest_paths(keypad, w[0], w[1])
+            .into_iter()
+            // convert paths to strings
+            .map(|path| path.iter().map(direction_to_char).collect::<String>())
+            // get the most efficient path (there are certain arbitrary rules for efficiency)
+            .max_by_key(|path| efficiency_score(path.as_str()))
+            .unwrap();
+        total_path.push_str(&best_path);
+        total_path.push_str("A");
+    }
+
+    total_path
+}
+
+fn shortest_paths(keypad: &Keypad, start: usize, end: usize) -> Vec<Vec<Direction>> {
+    fn path_costs(keypad: &Keypad, p: usize, cost_so_far: u64, costs: &mut HashMap<usize, u64>) {
+        if cost_so_far < costs.get(&p).copied().unwrap_or(u64::MAX) {
+            costs.insert(p, cost_so_far);
+        } else {
+            return;
+        }
+        for &adjacent in keypad.adjacents(p) {
+            path_costs(keypad, adjacent, cost_so_far + 1, costs);
+        }
+    }
+    let mut costs: HashMap<usize, u64> = HashMap::new();
+    path_costs(keypad, end, 0, &mut costs);
+
+    fn find_paths(
+        keypad: &Keypad,
+        start: usize,
+        costs: &HashMap<usize, u64>,
+    ) -> Vec<Vec<Direction>> {
+        if costs[&start] == 0 {
+            return vec![vec![]];
+        }
+        keypad.buttons[start]
+            .links
+            .iter()
+            .filter(|(_, adjacent)| costs[adjacent] < costs[&start])
+            .flat_map(|(&direction, &adjacent)| {
+                let mut paths = find_paths(keypad, adjacent, costs);
+                paths.iter_mut().for_each(|path| {
+                    path.insert(0, direction);
+                });
+                paths
+            })
+            .collect()
+    }
+
+    find_paths(keypad, start, &costs)
+}
+
+fn efficiency_score(s: &str) -> u64 {
+    let repetition_score = s
+        .chars()
+        .collect::<Vec<char>>()
+        .windows(2)
+        .filter(|w| w[0] == w[1])
+        .count() as u64;
+    let mut order_mishaps: u64 = 0;
+    for ss in s.split("A") {
+        order_mishaps += ss.matches(">v").count() as u64;
+        order_mishaps += ss.matches("^<").count() as u64;
+        order_mishaps += ss.matches("v<").count() as u64;
+        order_mishaps += ss.matches(">^").count() as u64;
+    }
+
+    (repetition_score << 32) | (u32::MAX as u64 - order_mishaps)
+}
+
+struct Keypad {
+    buttons: Vec<Button>,
+}
+
+impl Keypad {
+    fn adjacents(&self, button: usize) -> impl Iterator<Item = &usize> {
+        self.buttons[button].links.values()
+    }
+}
+
+#[derive(Default, Clone)]
+struct Button {
+    links: HashMap<Direction, usize>,
+}
+
+fn char_to_numerical_keypad_index(c: char) -> usize {
+    match c {
+        '7' => 0,
+        '8' => 1,
+        '9' => 2,
+        '4' => 3,
+        '5' => 4,
+        '6' => 5,
+        '1' => 6,
+        '2' => 7,
+        '3' => 8,
+        '0' => 9,
+        'A' => 10,
+        _ => panic!("The given char {c} has no place on a numerical keypad."),
+    }
+}
+
+fn char_to_directional_keypad_index(c: char) -> usize {
+    match c {
+        '^' => 0,
+        'A' => 1,
+        '<' => 2,
+        'v' => 3,
+        '>' => 4,
+        _ => panic!("The given char {c} has no place on a directional keypad."),
+    }
+}
+
+fn numerical_keypad() -> Keypad {
+    let mut buttons = vec![Button::default(); 11];
+    // 7
+    buttons[0].links.insert(Direction::East, 1);
+    buttons[0].links.insert(Direction::South, 3);
+    // 8
+    buttons[1].links.insert(Direction::West, 0);
+    buttons[1].links.insert(Direction::East, 2);
+    buttons[1].links.insert(Direction::South, 4);
+    // 9
+    buttons[2].links.insert(Direction::West, 1);
+    buttons[2].links.insert(Direction::South, 5);
+    // 4
+    buttons[3].links.insert(Direction::East, 4);
+    buttons[3].links.insert(Direction::North, 0);
+    buttons[3].links.insert(Direction::South, 6);
+    // 5
+    buttons[4].links.insert(Direction::West, 3);
+    buttons[4].links.insert(Direction::East, 5);
+    buttons[4].links.insert(Direction::South, 7);
+    buttons[4].links.insert(Direction::North, 1);
+    // 6
+    buttons[5].links.insert(Direction::West, 4);
+    buttons[5].links.insert(Direction::South, 8);
+    buttons[5].links.insert(Direction::North, 2);
+    // 1
+    buttons[6].links.insert(Direction::North, 3);
+    buttons[6].links.insert(Direction::East, 7);
+    // 2
+    buttons[7].links.insert(Direction::West, 6);
+    buttons[7].links.insert(Direction::East, 8);
+    buttons[7].links.insert(Direction::North, 4);
+    buttons[7].links.insert(Direction::South, 9);
+    // 3
+    buttons[8].links.insert(Direction::North, 5);
+    buttons[8].links.insert(Direction::West, 7);
+    buttons[8].links.insert(Direction::South, 10);
+    // 0
+    buttons[9].links.insert(Direction::North, 7);
+    buttons[9].links.insert(Direction::East, 10);
+    // A
+    buttons[10].links.insert(Direction::West, 9);
+    buttons[10].links.insert(Direction::North, 8);
+
+    Keypad { buttons }
+}
+
+fn directional_keypad() -> Keypad {
+    let mut buttons = vec![Button::default(); 5];
+    // ^
+    buttons[0].links.insert(Direction::East, 1);
+    buttons[0].links.insert(Direction::South, 3);
+    // A
+    buttons[1].links.insert(Direction::West, 0);
+    buttons[1].links.insert(Direction::South, 4);
+    // <
+    buttons[2].links.insert(Direction::East, 3);
+    // v
+    buttons[3].links.insert(Direction::East, 4);
+    buttons[3].links.insert(Direction::North, 0);
+    buttons[3].links.insert(Direction::West, 2);
+    // >
+    buttons[4].links.insert(Direction::North, 1);
+    buttons[4].links.insert(Direction::West, 3);
+
+    Keypad { buttons }
+}
+
+fn direction_to_char(direction: &Direction) -> char {
+    match direction {
+        Direction::North => '^',
+        Direction::South => 'v',
+        Direction::West => '<',
+        Direction::East => '>',
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index fb4be0a..29d8a88 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -24,7 +24,9 @@ mod day18;
 mod day19;
 #[allow(dead_code)]
 mod day2;
+#[allow(dead_code)]
 mod day20;
+mod day21;
 #[allow(dead_code)]
 mod day3;
 #[allow(dead_code)]
@@ -41,7 +43,7 @@ mod day8;
 mod day9;
 
 fn main() {
-    day20::day20();
+    day21::day21();
 }
 
 pub fn input(day: u8) -> String {
diff --git a/src/util/maps.rs b/src/util/maps.rs
index a2eeb15..f33f120 100644
--- a/src/util/maps.rs
+++ b/src/util/maps.rs
@@ -1,4 +1,4 @@
-use std::{fmt::Display, intrinsics::atomic_cxchgweak_acquire_acquire};
+use std::fmt::Display;
 
 use itertools::Itertools;