diff --git a/aoc-solver/src/solution.rs b/aoc-solver/src/solution.rs
index 456d161..b327c75 100644
--- a/aoc-solver/src/solution.rs
+++ b/aoc-solver/src/solution.rs
@@ -32,13 +32,13 @@ impl std::fmt::Display for AocError {
 }
 
 pub trait Solution {
-    type F: fmt::Display;
-    type S: fmt::Display;
+    type A: fmt::Display;
+    type B: fmt::Display;
 
     fn default_input(&self) -> &'static str;
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError>;
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError>;
+    fn part_1(&self, input: &str) -> Result<Self::A, AocError>;
+    fn part_2(&self, input: &str) -> Result<Self::B, AocError>;
 
     fn run(&self, input: Option<String>, day: u32, year: u32) -> Vec<String> {
         let input = input.unwrap_or_else(|| self.default_input().to_owned());
diff --git a/aoc-solver/src/y2020/day01.rs b/aoc-solver/src/y2020/day01.rs
index a34fa62..f908d60 100644
--- a/aoc-solver/src/y2020/day01.rs
+++ b/aoc-solver/src/y2020/day01.rs
@@ -3,8 +3,8 @@ use crate::solution::{AocError, Solution};
 pub struct Day01;
 
 impl Solution for Day01 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day01.txt")
diff --git a/aoc-solver/src/y2020/day02.rs b/aoc-solver/src/y2020/day02.rs
index bba77bf..ae9062f 100644
--- a/aoc-solver/src/y2020/day02.rs
+++ b/aoc-solver/src/y2020/day02.rs
@@ -45,8 +45,8 @@ fn parse_input(input: &str) -> Vec<DatabaseRow> {
 }
 
 impl Solution for Day02 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day02.txt")
diff --git a/aoc-solver/src/y2020/day03.rs b/aoc-solver/src/y2020/day03.rs
index 60528b3..cfab28d 100644
--- a/aoc-solver/src/y2020/day03.rs
+++ b/aoc-solver/src/y2020/day03.rs
@@ -44,8 +44,8 @@ fn parse(input: &str) -> (HashSet<(usize, usize)>, usize, usize) {
 }
 
 impl Solution for Day03 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day03.txt")
diff --git a/aoc-solver/src/y2020/day04.rs b/aoc-solver/src/y2020/day04.rs
index 564b27c..10c1c2b 100644
--- a/aoc-solver/src/y2020/day04.rs
+++ b/aoc-solver/src/y2020/day04.rs
@@ -178,8 +178,8 @@ fn parse_passport_part2(input: &str) -> IResult<&str, Passport> {
 }
 
 impl Solution for Day04 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day04.txt")
diff --git a/aoc-solver/src/y2020/day05.rs b/aoc-solver/src/y2020/day05.rs
index 5518c45..2c5a028 100644
--- a/aoc-solver/src/y2020/day05.rs
+++ b/aoc-solver/src/y2020/day05.rs
@@ -30,8 +30,8 @@ fn parse_boarding_pass(input: &str) -> BoardingPass {
 }
 
 impl Solution for Day05 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day05.txt")
diff --git a/aoc-solver/src/y2020/day06.rs b/aoc-solver/src/y2020/day06.rs
index 73acc99..f22e840 100644
--- a/aoc-solver/src/y2020/day06.rs
+++ b/aoc-solver/src/y2020/day06.rs
@@ -25,8 +25,8 @@ fn parse_answers_2(input: &str) -> HashSet<char> {
 }
 
 impl Solution for Day06 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day06.txt")
diff --git a/aoc-solver/src/y2020/day07.rs b/aoc-solver/src/y2020/day07.rs
index bb3de93..4cdf123 100644
--- a/aoc-solver/src/y2020/day07.rs
+++ b/aoc-solver/src/y2020/day07.rs
@@ -84,8 +84,8 @@ fn find_inner_bags_count(current: String, rules: HashMap<String, Rule>) -> usize
 }
 
 impl Solution for Day07 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day07.txt")
diff --git a/aoc-solver/src/y2020/day08.rs b/aoc-solver/src/y2020/day08.rs
index d752c5e..520efe5 100644
--- a/aoc-solver/src/y2020/day08.rs
+++ b/aoc-solver/src/y2020/day08.rs
@@ -87,14 +87,14 @@ fn parse_instruction(input: &str) -> IResult<&str, Instruction> {
 }
 
 impl Solution for Day08 {
-    type F = i32;
-    type S = i32;
+    type A = i32;
+    type B = i32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day08.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<i32, AocError> {
         let instructions: Vec<Instruction> = input
             .lines()
             .filter_map(|line| parse_instruction(line).ok())
@@ -111,7 +111,7 @@ impl Solution for Day08 {
         Ok(console.accumulator)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<i32, AocError> {
         let corrupted_instructions: Vec<Instruction> = input
             .lines()
             .filter_map(|line| parse_instruction(line).ok())
diff --git a/aoc-solver/src/y2020/day09.rs b/aoc-solver/src/y2020/day09.rs
index 61b581e..0ee9772 100644
--- a/aoc-solver/src/y2020/day09.rs
+++ b/aoc-solver/src/y2020/day09.rs
@@ -69,18 +69,18 @@ fn solve_part2(input: &str, preamble_len: usize) -> Result<usize, AocError> {
 }
 
 impl Solution for Day09 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day09.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         solve_part1(input, 25)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         solve_part2(input, 25)
     }
 }
diff --git a/aoc-solver/src/y2020/day10.rs b/aoc-solver/src/y2020/day10.rs
index 9f710a6..d0b656b 100644
--- a/aoc-solver/src/y2020/day10.rs
+++ b/aoc-solver/src/y2020/day10.rs
@@ -107,21 +107,21 @@ impl Solver {
 }
 
 impl Solution for Day10 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day10.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<i64, AocError> {
         let solver = Solver::new(input);
         let result = solver.part_1();
 
         Ok(result)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<i64, AocError> {
         let mut solver = Solver::new(input);
         let result = solver.part_2();
 
diff --git a/aoc-solver/src/y2020/day11.rs b/aoc-solver/src/y2020/day11.rs
index 9955c1a..6b86f34 100644
--- a/aoc-solver/src/y2020/day11.rs
+++ b/aoc-solver/src/y2020/day11.rs
@@ -157,8 +157,8 @@ impl GameOfSeats {
 }
 
 impl Solution for Day11 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day11.txt")
diff --git a/aoc-solver/src/y2020/day12.rs b/aoc-solver/src/y2020/day12.rs
index 33a9c2a..efb2cda 100644
--- a/aoc-solver/src/y2020/day12.rs
+++ b/aoc-solver/src/y2020/day12.rs
@@ -10,8 +10,8 @@ pub struct Ship {
 }
 
 impl Solution for Day12 {
-    type F = i32;
-    type S = i32;
+    type A = i32;
+    type B = i32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day12.txt")
diff --git a/aoc-solver/src/y2020/day13.rs b/aoc-solver/src/y2020/day13.rs
index c9a0980..5b99105 100644
--- a/aoc-solver/src/y2020/day13.rs
+++ b/aoc-solver/src/y2020/day13.rs
@@ -23,8 +23,8 @@ fn mod_inv(a: i64, module: i64) -> i64 {
 }
 
 impl Solution for Day13 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day13.txt")
diff --git a/aoc-solver/src/y2020/day14.rs b/aoc-solver/src/y2020/day14.rs
index 065c048..091c2e1 100644
--- a/aoc-solver/src/y2020/day14.rs
+++ b/aoc-solver/src/y2020/day14.rs
@@ -7,8 +7,8 @@ use crate::solution::{AocError, Solution};
 pub struct Day14;
 
 impl Solution for Day14 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day14.txt")
diff --git a/aoc-solver/src/y2020/day15.rs b/aoc-solver/src/y2020/day15.rs
index 880cf81..5f354db 100644
--- a/aoc-solver/src/y2020/day15.rs
+++ b/aoc-solver/src/y2020/day15.rs
@@ -31,8 +31,8 @@ fn memory_game(input: &str, turns: u32) -> u32 {
 }
 
 impl Solution for Day15 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day15.txt")
diff --git a/aoc-solver/src/y2020/day16.rs b/aoc-solver/src/y2020/day16.rs
index a909500..33cdd2c 100644
--- a/aoc-solver/src/y2020/day16.rs
+++ b/aoc-solver/src/y2020/day16.rs
@@ -143,8 +143,8 @@ fn parse_part_2(input: &str) -> Option<(Ticket, Vec<TicketField>)> {
 }
 
 impl Solution for Day16 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day16.txt")
diff --git a/aoc-solver/src/y2020/day17.rs b/aoc-solver/src/y2020/day17.rs
index 9bca5ad..32fef42 100644
--- a/aoc-solver/src/y2020/day17.rs
+++ b/aoc-solver/src/y2020/day17.rs
@@ -201,8 +201,8 @@ impl GameOfCubes {
 }
 
 impl Solution for Day17 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day17.txt")
diff --git a/aoc-solver/src/y2020/day18.rs b/aoc-solver/src/y2020/day18.rs
index 18720d3..2a81d1d 100644
--- a/aoc-solver/src/y2020/day18.rs
+++ b/aoc-solver/src/y2020/day18.rs
@@ -82,8 +82,8 @@ fn evaluate_rpn(mut rpn: VecDeque<char>) -> i64 {
 }
 
 impl Solution for Day18 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day18.txt")
diff --git a/aoc-solver/src/y2020/day19.rs b/aoc-solver/src/y2020/day19.rs
index 49ef2c3..01b4fb6 100644
--- a/aoc-solver/src/y2020/day19.rs
+++ b/aoc-solver/src/y2020/day19.rs
@@ -190,8 +190,8 @@ fn count_valid_grammar(input: &str) -> usize {
 }
 
 impl Solution for Day19 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day19.txt")
diff --git a/aoc-solver/src/y2020/day20.rs b/aoc-solver/src/y2020/day20.rs
index e867fde..4658f2c 100644
--- a/aoc-solver/src/y2020/day20.rs
+++ b/aoc-solver/src/y2020/day20.rs
@@ -282,8 +282,8 @@ impl Solver {
 }
 
 impl Solution for Day20 {
-    type F = u64;
-    type S = usize;
+    type A = u64;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day20.txt")
diff --git a/aoc-solver/src/y2020/day21.rs b/aoc-solver/src/y2020/day21.rs
index b65c246..4128de5 100644
--- a/aoc-solver/src/y2020/day21.rs
+++ b/aoc-solver/src/y2020/day21.rs
@@ -23,8 +23,8 @@ fn parse_line(input: &str) -> (HashSet<&str>, HashSet<&str>) {
 }
 
 impl Solution for Day21 {
-    type F = usize;
-    type S = String;
+    type A = usize;
+    type B = String;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day21.txt")
diff --git a/aoc-solver/src/y2020/day22.rs b/aoc-solver/src/y2020/day22.rs
index 519d976..7d45cfb 100644
--- a/aoc-solver/src/y2020/day22.rs
+++ b/aoc-solver/src/y2020/day22.rs
@@ -90,8 +90,8 @@ fn play_recursive_game(
 }
 
 impl Solution for Day22 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day22.txt")
diff --git a/aoc-solver/src/y2020/day23.rs b/aoc-solver/src/y2020/day23.rs
index 42646e2..297fa45 100644
--- a/aoc-solver/src/y2020/day23.rs
+++ b/aoc-solver/src/y2020/day23.rs
@@ -75,8 +75,8 @@ fn play(input: &str, moves: u32) -> Result<String, AocError> {
 }
 
 impl Solution for Day23 {
-    type F = String;
-    type S = u64;
+    type A = String;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day23.txt")
diff --git a/aoc-solver/src/y2020/day24.rs b/aoc-solver/src/y2020/day24.rs
index f14ccb1..f520f03 100644
--- a/aoc-solver/src/y2020/day24.rs
+++ b/aoc-solver/src/y2020/day24.rs
@@ -143,8 +143,8 @@ impl GameOfTiles {
 }
 
 impl Solution for Day24 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day24.txt")
diff --git a/aoc-solver/src/y2020/day25.rs b/aoc-solver/src/y2020/day25.rs
index ac1ee43..339c102 100644
--- a/aoc-solver/src/y2020/day25.rs
+++ b/aoc-solver/src/y2020/day25.rs
@@ -19,8 +19,8 @@ fn transform_subject_num(subject_number: u64, loop_size: u64) -> u64 {
 }
 
 impl Solution for Day25 {
-    type F = u64;
-    type S = String;
+    type A = u64;
+    type B = String;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2020/day01.txt")
diff --git a/aoc-solver/src/y2021/day01.rs b/aoc-solver/src/y2021/day01.rs
index 586364b..b01234f 100644
--- a/aoc-solver/src/y2021/day01.rs
+++ b/aoc-solver/src/y2021/day01.rs
@@ -17,8 +17,8 @@ where
 }
 
 impl Solution for Day01 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day01.txt")
diff --git a/aoc-solver/src/y2021/day02.rs b/aoc-solver/src/y2021/day02.rs
index fbb3d37..e40b204 100644
--- a/aoc-solver/src/y2021/day02.rs
+++ b/aoc-solver/src/y2021/day02.rs
@@ -3,14 +3,14 @@ use crate::solution::{AocError, Solution};
 pub struct Day02;
 
 impl Solution for Day02 {
-    type F = i32;
-    type S = i32;
+    type A = i32;
+    type B = i32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day02.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<i32, AocError> {
         let mut position: (i32, i32) = (0, 0);
 
         for command in input.lines() {
@@ -28,7 +28,7 @@ impl Solution for Day02 {
         Ok(position.0 * position.1)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<i32, AocError> {
         let mut position: (i32, i32) = (0, 0);
         let mut aim = 0;
 
diff --git a/aoc-solver/src/y2021/day03.rs b/aoc-solver/src/y2021/day03.rs
index 4ef0534..731c805 100644
--- a/aoc-solver/src/y2021/day03.rs
+++ b/aoc-solver/src/y2021/day03.rs
@@ -53,14 +53,14 @@ fn filter_by_bit_criteria(mut candidates: Vec<Vec<u32>>, expected_value: u32) ->
 }
 
 impl Solution for Day03 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day03.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<u32, AocError> {
         let bits_length = input.lines().next().unwrap_or("").len();
         let numbers = parse(input);
 
@@ -94,7 +94,7 @@ impl Solution for Day03 {
         Ok(decimal_most_common * decimal_least_common)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<u32, AocError> {
         let numbers = parse(input);
 
         let ogr_candidates = filter_by_bit_criteria(numbers.clone(), 1);
diff --git a/aoc-solver/src/y2021/day04.rs b/aoc-solver/src/y2021/day04.rs
index 9b472e7..c4d15bc 100644
--- a/aoc-solver/src/y2021/day04.rs
+++ b/aoc-solver/src/y2021/day04.rs
@@ -55,14 +55,14 @@ fn parse(input: &str) -> (Vec<usize>, Vec<Board>) {
 }
 
 impl Solution for Day04 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day04.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         let (numbers_input, boards) = parse(input);
         let mut drawn: HashSet<usize> = HashSet::new();
 
@@ -80,7 +80,7 @@ impl Solution for Day04 {
         Err(AocError::logic("No winners!"))
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let (numbers_input, mut boards) = parse(input);
         let mut drawn: HashSet<usize> = HashSet::new();
 
diff --git a/aoc-solver/src/y2021/day05.rs b/aoc-solver/src/y2021/day05.rs
index 1aa9f45..30cca79 100644
--- a/aoc-solver/src/y2021/day05.rs
+++ b/aoc-solver/src/y2021/day05.rs
@@ -68,18 +68,18 @@ fn solve(input: &str, is_allow_diagonal: bool) -> usize {
 }
 
 impl Solution for Day05 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day05.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         Ok(solve(input, false))
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         Ok(solve(input, true))
     }
 }
diff --git a/aoc-solver/src/y2021/day06.rs b/aoc-solver/src/y2021/day06.rs
index 5d886a1..9d88bdd 100644
--- a/aoc-solver/src/y2021/day06.rs
+++ b/aoc-solver/src/y2021/day06.rs
@@ -49,18 +49,18 @@ fn solve(input: &str, days: usize) -> u64 {
 }
 
 impl Solution for Day06 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day06.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<u64, AocError> {
         Ok(solve(input, 80))
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<u64, AocError> {
         Ok(solve(input, 256))
     }
 }
diff --git a/aoc-solver/src/y2021/day07.rs b/aoc-solver/src/y2021/day07.rs
index e4536f4..25d434d 100644
--- a/aoc-solver/src/y2021/day07.rs
+++ b/aoc-solver/src/y2021/day07.rs
@@ -13,14 +13,14 @@ fn parse(input: &str) -> Vec<usize> {
 }
 
 impl Solution for Day07 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day07.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         let depths = parse(input);
 
         let max_depth = *depths.iter().max().unwrap_or(&0);
@@ -40,7 +40,7 @@ impl Solution for Day07 {
         costs.into_iter().min().ok_or(AocError::logic("No minimum"))
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let depths = parse(input);
 
         let max_depth = *depths.iter().max().unwrap_or(&0);
diff --git a/aoc-solver/src/y2021/day08.rs b/aoc-solver/src/y2021/day08.rs
index 0b77a71..e994d34 100644
--- a/aoc-solver/src/y2021/day08.rs
+++ b/aoc-solver/src/y2021/day08.rs
@@ -130,14 +130,14 @@ fn signal_to_decimal_mappings(unique_signal_patterns: Vec<HashSet<char>>) -> Has
 }
 
 impl Solution for Day08 {
-    type F = usize;
-    type S = u32;
+    type A = usize;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day08.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         let displays = parse(input);
 
         let sum = displays
@@ -158,7 +158,7 @@ impl Solution for Day08 {
         Ok(sum)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<u32, AocError> {
         let displays = parse(input);
 
         let sum = displays
diff --git a/aoc-solver/src/y2021/day09.rs b/aoc-solver/src/y2021/day09.rs
index 7398ec2..33e3d7b 100644
--- a/aoc-solver/src/y2021/day09.rs
+++ b/aoc-solver/src/y2021/day09.rs
@@ -77,14 +77,14 @@ fn find_basin_recursive(
 }
 
 impl Solution for Day09 {
-    type F = u32;
-    type S = usize;
+    type A = u32;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day09.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<u32, AocError> {
         let heightmap = parse(input);
 
         let low_spots = find_low_spots(&heightmap)
@@ -95,7 +95,7 @@ impl Solution for Day09 {
         Ok(low_spots)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let heightmap = parse(input);
 
         let low_spots = find_low_spots(&heightmap);
diff --git a/aoc-solver/src/y2021/day10.rs b/aoc-solver/src/y2021/day10.rs
index 970ba65..e49d9b8 100644
--- a/aoc-solver/src/y2021/day10.rs
+++ b/aoc-solver/src/y2021/day10.rs
@@ -103,18 +103,18 @@ fn parse_with_autocomplete(input: &str) -> Option<Vec<char>> {
 }
 
 impl Solution for Day10 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day10.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         Ok(input.lines().map(parse).map(score_syntax_error).sum())
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let mut scores: Vec<usize> = input
             .lines()
             .flat_map(parse_with_autocomplete)
diff --git a/aoc-solver/src/y2021/day11.rs b/aoc-solver/src/y2021/day11.rs
index aa19ec2..0b8d14c 100644
--- a/aoc-solver/src/y2021/day11.rs
+++ b/aoc-solver/src/y2021/day11.rs
@@ -85,14 +85,14 @@ fn simulate_step(mut octopuses: Vec<Vec<u32>>) -> (Vec<Vec<u32>>, usize) {
 }
 
 impl Solution for Day11 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day11.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         let mut octopuses = parse(input);
 
         let mut total_flashes = 0;
@@ -105,7 +105,7 @@ impl Solution for Day11 {
         Ok(total_flashes)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let mut octopuses = parse(input);
 
         let total_octopuses_count: usize = octopuses.iter().map(|row| row.len()).sum();
diff --git a/aoc-solver/src/y2021/day12.rs b/aoc-solver/src/y2021/day12.rs
index 8832039..d13dcdf 100644
--- a/aoc-solver/src/y2021/day12.rs
+++ b/aoc-solver/src/y2021/day12.rs
@@ -82,21 +82,21 @@ fn search_paths_part2<'a>(
 }
 
 impl Solution for Day12 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day12.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         let caves = parse(input);
         let result = search_paths(&caves, "start", vec![]);
 
         Ok(result)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let caves = parse(input);
         let result = search_paths_part2(&caves, "start", vec![], false);
 
diff --git a/aoc-solver/src/y2021/day13.rs b/aoc-solver/src/y2021/day13.rs
index a59f571..8fc78e8 100644
--- a/aoc-solver/src/y2021/day13.rs
+++ b/aoc-solver/src/y2021/day13.rs
@@ -102,14 +102,14 @@ fn fold_paper(dots: &mut HashSet<Coords>, fold: Fold) {
 }
 
 impl Solution for Day13 {
-    type F = usize;
-    type S = String;
+    type A = usize;
+    type B = String;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day13.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         let (mut dots, folds) = parse(input);
 
         folds
@@ -120,7 +120,7 @@ impl Solution for Day13 {
         Ok(dots.len())
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<String, AocError> {
         let (mut dots, folds) = parse(input);
 
         folds
diff --git a/aoc-solver/src/y2021/day14.rs b/aoc-solver/src/y2021/day14.rs
index a0c2262..4e35914 100644
--- a/aoc-solver/src/y2021/day14.rs
+++ b/aoc-solver/src/y2021/day14.rs
@@ -125,19 +125,19 @@ fn solve(input: &str, steps: usize) -> usize {
 }
 
 impl Solution for Day14 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day14.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         let result = solve(input, 10);
         Ok(result)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let result = solve(input, 40);
         Ok(result)
     }
diff --git a/aoc-solver/src/y2021/day15.rs b/aoc-solver/src/y2021/day15.rs
index a24fed7..ea29944 100644
--- a/aoc-solver/src/y2021/day15.rs
+++ b/aoc-solver/src/y2021/day15.rs
@@ -123,19 +123,19 @@ fn solve(grid: Vec<Vec<u32>>) -> Result<u32, AocError> {
 }
 
 impl Solution for Day15 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day15.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<u32, AocError> {
         let grid = parse_repeating(input, 1);
         solve(grid)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<u32, AocError> {
         let grid = parse_repeating(input, 5);
         solve(grid)
     }
diff --git a/aoc-solver/src/y2021/day16.rs b/aoc-solver/src/y2021/day16.rs
index 05c718f..5934e18 100644
--- a/aoc-solver/src/y2021/day16.rs
+++ b/aoc-solver/src/y2021/day16.rs
@@ -201,21 +201,21 @@ fn packet_value(packet: &Packet) -> u64 {
 }
 
 impl Solution for Day16 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day16.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<u64, AocError> {
         let bit_stream = decode_hex_input(input).unwrap();
         let (_remaining, packet) = parse_packet((&bit_stream, 0)).unwrap();
 
         Ok(version_sum(&packet))
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<u64, AocError> {
         let bit_stream = decode_hex_input(input).unwrap();
         let (_remaining, packet) = parse_packet((&bit_stream, 0)).unwrap();
 
diff --git a/aoc-solver/src/y2021/day17.rs b/aoc-solver/src/y2021/day17.rs
index 2878c08..b7f964d 100644
--- a/aoc-solver/src/y2021/day17.rs
+++ b/aoc-solver/src/y2021/day17.rs
@@ -88,20 +88,20 @@ fn find_max_height(target_area: TargetArea, initial_x_v: i32, initial_y_v: i32)
 }
 
 impl Solution for Day17 {
-    type F = i32;
-    type S = usize;
+    type A = i32;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day17.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<i32, AocError> {
         let (part_1, _) = solve(input);
 
         Ok(part_1)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let (_, part_2) = solve(input);
 
         Ok(part_2)
diff --git a/aoc-solver/src/y2021/day18.rs b/aoc-solver/src/y2021/day18.rs
index 4e1ae15..684d050 100644
--- a/aoc-solver/src/y2021/day18.rs
+++ b/aoc-solver/src/y2021/day18.rs
@@ -360,21 +360,21 @@ fn add_list(input: &str) -> BinaryTree {
 }
 
 impl Solution for Day18 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day18.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<u32, AocError> {
         let result = add_list(input);
         let magnitude = result.magnitude();
 
         Ok(magnitude)
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<u32, AocError> {
         let mut largest_magnitude = 0;
 
         for (first, second) in input.lines().tuple_combinations() {
diff --git a/aoc-solver/src/y2021/day21.rs b/aoc-solver/src/y2021/day21.rs
index 0847dc1..c22f69c 100644
--- a/aoc-solver/src/y2021/day21.rs
+++ b/aoc-solver/src/y2021/day21.rs
@@ -71,14 +71,14 @@ fn play_quantum_turn(rolls: u32, mut players: [Player; 2], active_player: usize)
 }
 
 impl Solution for Day21 {
-    type F = u32;
-    type S = usize;
+    type A = u32;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day21.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<u32, AocError> {
         let mut players = parse(input);
 
         let mut deterministic_dice = 1;
@@ -105,7 +105,7 @@ impl Solution for Day21 {
         }
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         let players = parse(input);
         let active_player = 0;
 
diff --git a/aoc-solver/src/y2021/day22.rs b/aoc-solver/src/y2021/day22.rs
index bcb5716..7aa2f69 100644
--- a/aoc-solver/src/y2021/day22.rs
+++ b/aoc-solver/src/y2021/day22.rs
@@ -166,18 +166,18 @@ fn reboot_reactor(input: &str, initialization_procedure: bool) -> usize {
 }
 
 impl Solution for Day22 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2021/day22.txt")
     }
 
-    fn part_1(&self, input: &str) -> Result<Self::F, AocError> {
+    fn part_1(&self, input: &str) -> Result<usize, AocError> {
         Ok(reboot_reactor(input, true))
     }
 
-    fn part_2(&self, input: &str) -> Result<Self::S, AocError> {
+    fn part_2(&self, input: &str) -> Result<usize, AocError> {
         Ok(reboot_reactor(input, false))
     }
 }
diff --git a/aoc-solver/src/y2022/day01.rs b/aoc-solver/src/y2022/day01.rs
index be7b3f7..0990d69 100644
--- a/aoc-solver/src/y2022/day01.rs
+++ b/aoc-solver/src/y2022/day01.rs
@@ -21,8 +21,8 @@ fn parse(input: &str) -> Result<Vec<u64>, AocError> {
 }
 
 impl Solution for Day01 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day01.txt")
diff --git a/aoc-solver/src/y2022/day02.rs b/aoc-solver/src/y2022/day02.rs
index ea92e76..8998054 100644
--- a/aoc-solver/src/y2022/day02.rs
+++ b/aoc-solver/src/y2022/day02.rs
@@ -42,8 +42,8 @@ fn score(selected: Rps, outcome: Outcome) -> i64 {
 }
 
 impl Solution for Day02 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day02.txt")
diff --git a/aoc-solver/src/y2022/day03.rs b/aoc-solver/src/y2022/day03.rs
index 0d4f720..8150b3b 100644
--- a/aoc-solver/src/y2022/day03.rs
+++ b/aoc-solver/src/y2022/day03.rs
@@ -17,8 +17,8 @@ fn as_priority(item: u8) -> u32 {
 }
 
 impl Solution for Day03 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day03.txt")
diff --git a/aoc-solver/src/y2022/day04.rs b/aoc-solver/src/y2022/day04.rs
index 0384787..76344eb 100644
--- a/aoc-solver/src/y2022/day04.rs
+++ b/aoc-solver/src/y2022/day04.rs
@@ -28,8 +28,8 @@ fn parse(input: &str) -> Result<Pairs, AocError> {
 }
 
 impl Solution for Day04 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day04.txt")
diff --git a/aoc-solver/src/y2022/day05.rs b/aoc-solver/src/y2022/day05.rs
index 83a9c38..1624255 100644
--- a/aoc-solver/src/y2022/day05.rs
+++ b/aoc-solver/src/y2022/day05.rs
@@ -53,8 +53,8 @@ fn top_crates(crates: Vec<Vec<char>>) -> String {
 }
 
 impl Solution for Day05 {
-    type F = String;
-    type S = String;
+    type A = String;
+    type B = String;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day05.txt")
diff --git a/aoc-solver/src/y2022/day06.rs b/aoc-solver/src/y2022/day06.rs
index f65ee26..13bb946 100644
--- a/aoc-solver/src/y2022/day06.rs
+++ b/aoc-solver/src/y2022/day06.rs
@@ -15,8 +15,8 @@ fn find_marker(signal: Vec<char>, marker_len: usize) -> Result<usize, AocError>
 }
 
 impl Solution for Day06 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day06.txt")
diff --git a/aoc-solver/src/y2022/day07.rs b/aoc-solver/src/y2022/day07.rs
index f917cbc..de3f6cb 100644
--- a/aoc-solver/src/y2022/day07.rs
+++ b/aoc-solver/src/y2022/day07.rs
@@ -79,8 +79,8 @@ fn find_directory_sizes(node: &FsNode) -> Vec<usize> {
 }
 
 impl Solution for Day07 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day07.txt")
diff --git a/aoc-solver/src/y2022/day08.rs b/aoc-solver/src/y2022/day08.rs
index 440ceb3..43c9ccc 100644
--- a/aoc-solver/src/y2022/day08.rs
+++ b/aoc-solver/src/y2022/day08.rs
@@ -32,8 +32,8 @@ fn parse(input: &str) -> Result<Vec<Vec<(i32, bool)>>, AocError> {
 }
 
 impl Solution for Day08 {
-    type F = i32;
-    type S = i32;
+    type A = i32;
+    type B = i32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day08.txt")
diff --git a/aoc-solver/src/y2022/day09.rs b/aoc-solver/src/y2022/day09.rs
index 4204a8f..5a12f76 100644
--- a/aoc-solver/src/y2022/day09.rs
+++ b/aoc-solver/src/y2022/day09.rs
@@ -103,8 +103,8 @@ impl Day09 {
 }
 
 impl Solution for Day09 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day09.txt")
diff --git a/aoc-solver/src/y2022/day10.rs b/aoc-solver/src/y2022/day10.rs
index 8e08fe3..d33853c 100644
--- a/aoc-solver/src/y2022/day10.rs
+++ b/aoc-solver/src/y2022/day10.rs
@@ -34,8 +34,8 @@ impl Day10 {
 }
 
 impl Solution for Day10 {
-    type F = i32;
-    type S = String;
+    type A = i32;
+    type B = String;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day10.txt")
diff --git a/aoc-solver/src/y2022/day11.rs b/aoc-solver/src/y2022/day11.rs
index 3c0bbe4..8981433 100644
--- a/aoc-solver/src/y2022/day11.rs
+++ b/aoc-solver/src/y2022/day11.rs
@@ -130,8 +130,8 @@ impl Day11 {
 }
 
 impl Solution for Day11 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day11.txt")
diff --git a/aoc-solver/src/y2022/day12.rs b/aoc-solver/src/y2022/day12.rs
index fb57c46..7525246 100644
--- a/aoc-solver/src/y2022/day12.rs
+++ b/aoc-solver/src/y2022/day12.rs
@@ -111,8 +111,8 @@ fn dijkstra(grid: Vec<Vec<u8>>, source: Coord, target: Coord) -> Option<u32> {
 }
 
 impl Solution for Day12 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day12.txt")
diff --git a/aoc-solver/src/y2022/day13.rs b/aoc-solver/src/y2022/day13.rs
index e630737..88bc10c 100644
--- a/aoc-solver/src/y2022/day13.rs
+++ b/aoc-solver/src/y2022/day13.rs
@@ -107,8 +107,8 @@ fn parse(input: &str) -> IResult<&str, Vec<[Packet; 2]>> {
 pub struct Day13;
 
 impl Solution for Day13 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day13.txt")
diff --git a/aoc-solver/src/y2022/day14.rs b/aoc-solver/src/y2022/day14.rs
index 8df12b0..2ab1a08 100644
--- a/aoc-solver/src/y2022/day14.rs
+++ b/aoc-solver/src/y2022/day14.rs
@@ -96,8 +96,8 @@ impl Day14 {
 }
 
 impl Solution for Day14 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day14.txt")
diff --git a/aoc-solver/src/y2022/day15.rs b/aoc-solver/src/y2022/day15.rs
index c0d5065..6d14a65 100644
--- a/aoc-solver/src/y2022/day15.rs
+++ b/aoc-solver/src/y2022/day15.rs
@@ -133,8 +133,8 @@ impl Day15 {
 }
 
 impl Solution for Day15 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day15.txt")
diff --git a/aoc-solver/src/y2022/day16.rs b/aoc-solver/src/y2022/day16.rs
index 29715dd..312bebf 100644
--- a/aoc-solver/src/y2022/day16.rs
+++ b/aoc-solver/src/y2022/day16.rs
@@ -215,8 +215,8 @@ impl Day16 {
 }
 
 impl Solution for Day16 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day16.txt")
diff --git a/aoc-solver/src/y2022/day17.rs b/aoc-solver/src/y2022/day17.rs
index 440afa4..e6e891c 100644
--- a/aoc-solver/src/y2022/day17.rs
+++ b/aoc-solver/src/y2022/day17.rs
@@ -153,8 +153,8 @@ impl Day17 {
 }
 
 impl Solution for Day17 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day17.txt")
diff --git a/aoc-solver/src/y2022/day18.rs b/aoc-solver/src/y2022/day18.rs
index f5dd6d1..82ec4e3 100644
--- a/aoc-solver/src/y2022/day18.rs
+++ b/aoc-solver/src/y2022/day18.rs
@@ -157,8 +157,8 @@ impl Day18 {
 }
 
 impl Solution for Day18 {
-    type F = usize;
-    type S = usize;
+    type A = usize;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day18.txt")
diff --git a/aoc-solver/src/y2022/day19.rs b/aoc-solver/src/y2022/day19.rs
index 8ad302c..576e58e 100644
--- a/aoc-solver/src/y2022/day19.rs
+++ b/aoc-solver/src/y2022/day19.rs
@@ -198,8 +198,8 @@ impl Day19 {
 }
 
 impl Solution for Day19 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day19.txt")
diff --git a/aoc-solver/src/y2022/day20.rs b/aoc-solver/src/y2022/day20.rs
index 52522df..c2c5b01 100644
--- a/aoc-solver/src/y2022/day20.rs
+++ b/aoc-solver/src/y2022/day20.rs
@@ -51,8 +51,8 @@ impl Day20 {
 }
 
 impl Solution for Day20 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day20.txt")
diff --git a/aoc-solver/src/y2022/day21.rs b/aoc-solver/src/y2022/day21.rs
index 072a3d8..dc11b48 100644
--- a/aoc-solver/src/y2022/day21.rs
+++ b/aoc-solver/src/y2022/day21.rs
@@ -79,8 +79,8 @@ impl Day21 {
 }
 
 impl Solution for Day21 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day21.txt")
diff --git a/aoc-solver/src/y2022/day22.rs b/aoc-solver/src/y2022/day22.rs
index 3dd1f56..1e28170 100644
--- a/aoc-solver/src/y2022/day22.rs
+++ b/aoc-solver/src/y2022/day22.rs
@@ -449,8 +449,8 @@ impl Day22 {
 }
 
 impl Solution for Day22 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
 
     fn default_input(&self) -> &'static str {
diff --git a/aoc-solver/src/y2022/day23.rs b/aoc-solver/src/y2022/day23.rs
index 432bdf9..8a4018b 100644
--- a/aoc-solver/src/y2022/day23.rs
+++ b/aoc-solver/src/y2022/day23.rs
@@ -94,8 +94,8 @@ impl Day23 {
 }
 
 impl Solution for Day23 {
-    type F = i64;
-    type S = usize;
+    type A = i64;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day23.txt")
diff --git a/aoc-solver/src/y2022/day24.rs b/aoc-solver/src/y2022/day24.rs
index 67c98d7..dd1f8ef 100644
--- a/aoc-solver/src/y2022/day24.rs
+++ b/aoc-solver/src/y2022/day24.rs
@@ -176,8 +176,8 @@ impl Day24 {
 }
 
 impl Solution for Day24 {
-    type F = i32;
-    type S = i32;
+    type A = i32;
+    type B = i32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day24.txt")
diff --git a/aoc-solver/src/y2022/day25.rs b/aoc-solver/src/y2022/day25.rs
index 45246ce..9fedf4a 100644
--- a/aoc-solver/src/y2022/day25.rs
+++ b/aoc-solver/src/y2022/day25.rs
@@ -50,8 +50,8 @@ impl Day25 {
 }
 
 impl Solution for Day25 {
-    type F = String;
-    type S = String;
+    type A = String;
+    type B = String;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2022/day25.txt")
diff --git a/aoc-solver/src/y2023/day01.rs b/aoc-solver/src/y2023/day01.rs
index 269995c..5574c85 100644
--- a/aoc-solver/src/y2023/day01.rs
+++ b/aoc-solver/src/y2023/day01.rs
@@ -7,8 +7,8 @@ const NUMBERS: [&str; 9] = [
 ];
 
 impl Solution for Day01 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day01.txt")
diff --git a/aoc-solver/src/y2023/day02.rs b/aoc-solver/src/y2023/day02.rs
index d9e6397..1005196 100644
--- a/aoc-solver/src/y2023/day02.rs
+++ b/aoc-solver/src/y2023/day02.rs
@@ -63,8 +63,8 @@ fn max_color_seen(hands: &[Hand], color_extractor: impl Fn(&Hand) -> u32) -> u32
 }
 
 impl Solution for Day02 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day02.txt")
diff --git a/aoc-solver/src/y2023/day03.rs b/aoc-solver/src/y2023/day03.rs
index c936e01..da43f89 100644
--- a/aoc-solver/src/y2023/day03.rs
+++ b/aoc-solver/src/y2023/day03.rs
@@ -51,8 +51,8 @@ fn parse(input: &str) -> Result<(Symbols, Numbers), AocError> {
 }
 
 impl Solution for Day03 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day03.txt")
diff --git a/aoc-solver/src/y2023/day04.rs b/aoc-solver/src/y2023/day04.rs
index 3358636..33979e4 100644
--- a/aoc-solver/src/y2023/day04.rs
+++ b/aoc-solver/src/y2023/day04.rs
@@ -45,8 +45,8 @@ fn parse_numbers(numbers: &str) -> Result<HashSet<u32>, AocError> {
 }
 
 impl Solution for Day04 {
-    type F = u32;
-    type S = usize;
+    type A = u32;
+    type B = usize;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day04.txt")
diff --git a/aoc-solver/src/y2023/day05.rs b/aoc-solver/src/y2023/day05.rs
index a8192b9..2f4f17a 100644
--- a/aoc-solver/src/y2023/day05.rs
+++ b/aoc-solver/src/y2023/day05.rs
@@ -87,8 +87,8 @@ fn parse_number(number: &str) -> Result<i64, AocError> {
 }
 
 impl Solution for Day05 {
-    type F = i64;
-    type S = i64;
+    type A = i64;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day05.txt")
diff --git a/aoc-solver/src/y2023/day06.rs b/aoc-solver/src/y2023/day06.rs
index fffc0f0..1c567b5 100644
--- a/aoc-solver/src/y2023/day06.rs
+++ b/aoc-solver/src/y2023/day06.rs
@@ -74,8 +74,8 @@ fn parse_part_2(input: &str) -> Result<Race, AocError> {
 }
 
 impl Solution for Day06 {
-    type F = usize;
-    type S = i64;
+    type A = usize;
+    type B = i64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day06.txt")
diff --git a/aoc-solver/src/y2023/day07.rs b/aoc-solver/src/y2023/day07.rs
index 621942f..6851d39 100644
--- a/aoc-solver/src/y2023/day07.rs
+++ b/aoc-solver/src/y2023/day07.rs
@@ -131,8 +131,8 @@ fn calculate_winnings(input: &str, scores: &[char], use_jokers: bool) -> Result<
 }
 
 impl Solution for Day07 {
-    type F = u32;
-    type S = u32;
+    type A = u32;
+    type B = u32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day07.txt")
diff --git a/aoc-solver/src/y2023/day08.rs b/aoc-solver/src/y2023/day08.rs
index 95f41f9..83d6f06 100644
--- a/aoc-solver/src/y2023/day08.rs
+++ b/aoc-solver/src/y2023/day08.rs
@@ -65,8 +65,8 @@ fn parse(input: &str) -> Result<(String, HashMap<String, Node>), AocError> {
 }
 
 impl Solution for Day08 {
-    type F = u64;
-    type S = u64;
+    type A = u64;
+    type B = u64;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day08.txt")
diff --git a/aoc-solver/src/y2023/day09.rs b/aoc-solver/src/y2023/day09.rs
index b849283..c12a7bd 100644
--- a/aoc-solver/src/y2023/day09.rs
+++ b/aoc-solver/src/y2023/day09.rs
@@ -50,8 +50,8 @@ fn extrapolate(mut sequence: Vec<i32>, direction: Direction) -> i32 {
 }
 
 impl Solution for Day09 {
-    type F = i32;
-    type S = i32;
+    type A = i32;
+    type B = i32;
 
     fn default_input(&self) -> &'static str {
         include_str!("../../../inputs/2023/day09.txt")