advent-of-code 2022.0.46

use advent_of_code::solve;
use std::fs::read_to_string;

fn problem_2015_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day01_input.txt").unwrap();
    solve(2015, 1, 1, &input).unwrap();
}

fn problem_2015_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day01_input.txt").unwrap();
    solve(2015, 1, 2, &input).unwrap();
}

fn problem_2015_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day02_input.txt").unwrap();
    solve(2015, 2, 1, &input).unwrap();
}

fn problem_2015_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day02_input.txt").unwrap();
    solve(2015, 2, 2, &input).unwrap();
}

fn problem_2015_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day03_input.txt").unwrap();
    solve(2015, 3, 1, &input).unwrap();
}

fn problem_2015_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day03_input.txt").unwrap();
    solve(2015, 3, 2, &input).unwrap();
}

fn problem_2015_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day04_input.txt").unwrap();
    solve(2015, 4, 1, &input).unwrap();
}

fn problem_2015_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day04_input.txt").unwrap();
    solve(2015, 4, 2, &input).unwrap();
}

fn problem_2015_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day05_input.txt").unwrap();
    solve(2015, 5, 1, &input).unwrap();
}

fn problem_2015_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day05_input.txt").unwrap();
    solve(2015, 5, 2, &input).unwrap();
}

fn problem_2015_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day06_input.txt").unwrap();
    solve(2015, 6, 1, &input).unwrap();
}

fn problem_2015_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day06_input.txt").unwrap();
    solve(2015, 6, 2, &input).unwrap();
}

fn problem_2015_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day07_input.txt").unwrap();
    solve(2015, 7, 1, &input).unwrap();
}

fn problem_2015_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day07_input.txt").unwrap();
    solve(2015, 7, 2, &input).unwrap();
}

fn problem_2015_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day08_input.txt").unwrap();
    solve(2015, 8, 1, &input).unwrap();
}

fn problem_2015_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day08_input.txt").unwrap();
    solve(2015, 8, 2, &input).unwrap();
}

fn problem_2015_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day09_input.txt").unwrap();
    solve(2015, 9, 1, &input).unwrap();
}

fn problem_2015_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day09_input.txt").unwrap();
    solve(2015, 9, 2, &input).unwrap();
}

fn problem_2015_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day10_input.txt").unwrap();
    solve(2015, 10, 1, &input).unwrap();
}

fn problem_2015_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day10_input.txt").unwrap();
    solve(2015, 10, 2, &input).unwrap();
}

fn problem_2015_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day11_input.txt").unwrap();
    solve(2015, 11, 1, &input).unwrap();
}

fn problem_2015_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day11_input.txt").unwrap();
    solve(2015, 11, 2, &input).unwrap();
}

fn problem_2015_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day12_input.txt").unwrap();
    solve(2015, 12, 1, &input).unwrap();
}

fn problem_2015_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day12_input.txt").unwrap();
    solve(2015, 12, 2, &input).unwrap();
}

fn problem_2015_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day13_input.txt").unwrap();
    solve(2015, 13, 1, &input).unwrap();
}

fn problem_2015_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day13_input.txt").unwrap();
    solve(2015, 13, 2, &input).unwrap();
}

fn problem_2015_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day14_input.txt").unwrap();
    solve(2015, 14, 1, &input).unwrap();
}

fn problem_2015_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day14_input.txt").unwrap();
    solve(2015, 14, 2, &input).unwrap();
}

fn problem_2015_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day15_input.txt").unwrap();
    solve(2015, 15, 1, &input).unwrap();
}

fn problem_2015_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day15_input.txt").unwrap();
    solve(2015, 15, 2, &input).unwrap();
}

fn problem_2015_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day16_input.txt").unwrap();
    solve(2015, 16, 1, &input).unwrap();
}

fn problem_2015_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day16_input.txt").unwrap();
    solve(2015, 16, 2, &input).unwrap();
}

fn problem_2015_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day17_input.txt").unwrap();
    solve(2015, 17, 1, &input).unwrap();
}

fn problem_2015_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day17_input.txt").unwrap();
    solve(2015, 17, 2, &input).unwrap();
}

fn problem_2015_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day18_input.txt").unwrap();
    solve(2015, 18, 1, &input).unwrap();
}

fn problem_2015_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day18_input.txt").unwrap();
    solve(2015, 18, 2, &input).unwrap();
}

fn problem_2015_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day19_input.txt").unwrap();
    solve(2015, 19, 1, &input).unwrap();
}

fn problem_2015_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day19_input.txt").unwrap();
    solve(2015, 19, 2, &input).unwrap();
}

fn problem_2015_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day20_input.txt").unwrap();
    solve(2015, 20, 1, &input).unwrap();
}

fn problem_2015_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day20_input.txt").unwrap();
    solve(2015, 20, 2, &input).unwrap();
}

fn problem_2015_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day21_input.txt").unwrap();
    solve(2015, 21, 1, &input).unwrap();
}

fn problem_2015_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day21_input.txt").unwrap();
    solve(2015, 21, 2, &input).unwrap();
}

fn problem_2015_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day22_input.txt").unwrap();
    solve(2015, 22, 1, &input).unwrap();
}

fn problem_2015_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day22_input.txt").unwrap();
    solve(2015, 22, 2, &input).unwrap();
}

fn problem_2015_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day23_input.txt").unwrap();
    solve(2015, 23, 1, &input).unwrap();
}

fn problem_2015_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day23_input.txt").unwrap();
    solve(2015, 23, 2, &input).unwrap();
}

fn problem_2015_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day24_input.txt").unwrap();
    solve(2015, 24, 1, &input).unwrap();
}

fn problem_2015_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day24_input.txt").unwrap();
    solve(2015, 24, 2, &input).unwrap();
}

fn problem_2015_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2015/day25_input.txt").unwrap();
    solve(2015, 25, 1, &input).unwrap();
}

fn problem_2016_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day01_input.txt").unwrap();
    solve(2016, 1, 1, &input).unwrap();
}

fn problem_2016_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day01_input.txt").unwrap();
    solve(2016, 1, 2, &input).unwrap();
}

fn problem_2016_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day02_input.txt").unwrap();
    solve(2016, 2, 1, &input).unwrap();
}

fn problem_2016_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day02_input.txt").unwrap();
    solve(2016, 2, 2, &input).unwrap();
}

fn problem_2016_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day03_input.txt").unwrap();
    solve(2016, 3, 1, &input).unwrap();
}

fn problem_2016_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day03_input.txt").unwrap();
    solve(2016, 3, 2, &input).unwrap();
}

fn problem_2016_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day04_input.txt").unwrap();
    solve(2016, 4, 1, &input).unwrap();
}

fn problem_2016_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day04_input.txt").unwrap();
    solve(2016, 4, 2, &input).unwrap();
}

fn problem_2016_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day05_input.txt").unwrap();
    solve(2016, 5, 1, &input).unwrap();
}

fn problem_2016_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day05_input.txt").unwrap();
    solve(2016, 5, 2, &input).unwrap();
}

fn problem_2016_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day06_input.txt").unwrap();
    solve(2016, 6, 1, &input).unwrap();
}

fn problem_2016_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day06_input.txt").unwrap();
    solve(2016, 6, 2, &input).unwrap();
}

fn problem_2016_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day07_input.txt").unwrap();
    solve(2016, 7, 1, &input).unwrap();
}

fn problem_2016_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day07_input.txt").unwrap();
    solve(2016, 7, 2, &input).unwrap();
}

fn problem_2016_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day08_input.txt").unwrap();
    solve(2016, 8, 1, &input).unwrap();
}

fn problem_2016_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day08_input.txt").unwrap();
    solve(2016, 8, 2, &input).unwrap();
}

fn problem_2016_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day09_input.txt").unwrap();
    solve(2016, 9, 1, &input).unwrap();
}

fn problem_2016_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day09_input.txt").unwrap();
    solve(2016, 9, 2, &input).unwrap();
}

fn problem_2016_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day10_input.txt").unwrap();
    solve(2016, 10, 1, &input).unwrap();
}

fn problem_2016_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day10_input.txt").unwrap();
    solve(2016, 10, 2, &input).unwrap();
}

fn problem_2016_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day11_input.txt").unwrap();
    solve(2016, 11, 1, &input).unwrap();
}

fn problem_2016_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day11_input.txt").unwrap();
    solve(2016, 11, 2, &input).unwrap();
}

fn problem_2016_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day12_input.txt").unwrap();
    solve(2016, 12, 1, &input).unwrap();
}

fn problem_2016_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day12_input.txt").unwrap();
    solve(2016, 12, 2, &input).unwrap();
}

fn problem_2016_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day13_input.txt").unwrap();
    solve(2016, 13, 1, &input).unwrap();
}

fn problem_2016_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day13_input.txt").unwrap();
    solve(2016, 13, 2, &input).unwrap();
}

fn problem_2016_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day14_input.txt").unwrap();
    solve(2016, 14, 1, &input).unwrap();
}

fn problem_2016_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day14_input.txt").unwrap();
    solve(2016, 14, 2, &input).unwrap();
}

fn problem_2016_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day15_input.txt").unwrap();
    solve(2016, 15, 1, &input).unwrap();
}

fn problem_2016_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day15_input.txt").unwrap();
    solve(2016, 15, 2, &input).unwrap();
}

fn problem_2016_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day16_input.txt").unwrap();
    solve(2016, 16, 1, &input).unwrap();
}

fn problem_2016_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day16_input.txt").unwrap();
    solve(2016, 16, 2, &input).unwrap();
}

fn problem_2016_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day17_input.txt").unwrap();
    solve(2016, 17, 1, &input).unwrap();
}

fn problem_2016_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day17_input.txt").unwrap();
    solve(2016, 17, 2, &input).unwrap();
}

fn problem_2016_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day18_input.txt").unwrap();
    solve(2016, 18, 1, &input).unwrap();
}

fn problem_2016_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day18_input.txt").unwrap();
    solve(2016, 18, 2, &input).unwrap();
}

fn problem_2016_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day19_input.txt").unwrap();
    solve(2016, 19, 1, &input).unwrap();
}

fn problem_2016_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day19_input.txt").unwrap();
    solve(2016, 19, 2, &input).unwrap();
}

fn problem_2016_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day20_input.txt").unwrap();
    solve(2016, 20, 1, &input).unwrap();
}

fn problem_2016_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day20_input.txt").unwrap();
    solve(2016, 20, 2, &input).unwrap();
}

fn problem_2016_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day21_input.txt").unwrap();
    solve(2016, 21, 1, &input).unwrap();
}

fn problem_2016_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day21_input.txt").unwrap();
    solve(2016, 21, 2, &input).unwrap();
}

fn problem_2016_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day22_input.txt").unwrap();
    solve(2016, 22, 1, &input).unwrap();
}

fn problem_2016_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day22_input.txt").unwrap();
    solve(2016, 22, 2, &input).unwrap();
}

fn problem_2016_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day23_input.txt").unwrap();
    solve(2016, 23, 1, &input).unwrap();
}

fn problem_2016_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day23_input.txt").unwrap();
    solve(2016, 23, 2, &input).unwrap();
}

fn problem_2016_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day24_input.txt").unwrap();
    solve(2016, 24, 1, &input).unwrap();
}

fn problem_2016_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day24_input.txt").unwrap();
    solve(2016, 24, 2, &input).unwrap();
}

fn problem_2016_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2016/day25_input.txt").unwrap();
    solve(2016, 25, 1, &input).unwrap();
}

fn problem_2017_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day01_input.txt").unwrap();
    solve(2017, 1, 1, &input).unwrap();
}

fn problem_2017_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day01_input.txt").unwrap();
    solve(2017, 1, 2, &input).unwrap();
}

fn problem_2017_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day02_input.txt").unwrap();
    solve(2017, 2, 1, &input).unwrap();
}

fn problem_2017_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day02_input.txt").unwrap();
    solve(2017, 2, 2, &input).unwrap();
}

fn problem_2017_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day03_input.txt").unwrap();
    solve(2017, 3, 1, &input).unwrap();
}

fn problem_2017_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day03_input.txt").unwrap();
    solve(2017, 3, 2, &input).unwrap();
}

fn problem_2017_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day04_input.txt").unwrap();
    solve(2017, 4, 1, &input).unwrap();
}

fn problem_2017_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day04_input.txt").unwrap();
    solve(2017, 4, 2, &input).unwrap();
}

fn problem_2017_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day05_input.txt").unwrap();
    solve(2017, 5, 1, &input).unwrap();
}

fn problem_2017_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day05_input.txt").unwrap();
    solve(2017, 5, 2, &input).unwrap();
}

fn problem_2017_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day06_input.txt").unwrap();
    solve(2017, 6, 1, &input).unwrap();
}

fn problem_2017_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day06_input.txt").unwrap();
    solve(2017, 6, 2, &input).unwrap();
}

fn problem_2017_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day07_input.txt").unwrap();
    solve(2017, 7, 1, &input).unwrap();
}

fn problem_2017_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day07_input.txt").unwrap();
    solve(2017, 7, 2, &input).unwrap();
}

fn problem_2017_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day08_input.txt").unwrap();
    solve(2017, 8, 1, &input).unwrap();
}

fn problem_2017_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day08_input.txt").unwrap();
    solve(2017, 8, 2, &input).unwrap();
}

fn problem_2017_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day09_input.txt").unwrap();
    solve(2017, 9, 1, &input).unwrap();
}

fn problem_2017_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day09_input.txt").unwrap();
    solve(2017, 9, 2, &input).unwrap();
}

fn problem_2017_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day10_input.txt").unwrap();
    solve(2017, 10, 1, &input).unwrap();
}

fn problem_2017_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day10_input.txt").unwrap();
    solve(2017, 10, 2, &input).unwrap();
}

fn problem_2017_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day11_input.txt").unwrap();
    solve(2017, 11, 1, &input).unwrap();
}

fn problem_2017_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day11_input.txt").unwrap();
    solve(2017, 11, 2, &input).unwrap();
}

fn problem_2017_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day12_input.txt").unwrap();
    solve(2017, 12, 1, &input).unwrap();
}

fn problem_2017_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day12_input.txt").unwrap();
    solve(2017, 12, 2, &input).unwrap();
}

fn problem_2017_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day13_input.txt").unwrap();
    solve(2017, 13, 1, &input).unwrap();
}

fn problem_2017_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day13_input.txt").unwrap();
    solve(2017, 13, 2, &input).unwrap();
}

fn problem_2017_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day14_input.txt").unwrap();
    solve(2017, 14, 1, &input).unwrap();
}

fn problem_2017_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day14_input.txt").unwrap();
    solve(2017, 14, 2, &input).unwrap();
}

fn problem_2017_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day15_input.txt").unwrap();
    solve(2017, 15, 1, &input).unwrap();
}

fn problem_2017_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day15_input.txt").unwrap();
    solve(2017, 15, 2, &input).unwrap();
}

fn problem_2017_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day16_input.txt").unwrap();
    solve(2017, 16, 1, &input).unwrap();
}

fn problem_2017_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day16_input.txt").unwrap();
    solve(2017, 16, 2, &input).unwrap();
}

fn problem_2017_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day17_input.txt").unwrap();
    solve(2017, 17, 1, &input).unwrap();
}

fn problem_2017_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day17_input.txt").unwrap();
    solve(2017, 17, 2, &input).unwrap();
}

fn problem_2017_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day18_input.txt").unwrap();
    solve(2017, 18, 1, &input).unwrap();
}

fn problem_2017_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day18_input.txt").unwrap();
    solve(2017, 18, 2, &input).unwrap();
}

fn problem_2017_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day19_input.txt").unwrap();
    solve(2017, 19, 1, &input).unwrap();
}

fn problem_2017_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day19_input.txt").unwrap();
    solve(2017, 19, 2, &input).unwrap();
}

fn problem_2017_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day20_input.txt").unwrap();
    solve(2017, 20, 1, &input).unwrap();
}

fn problem_2017_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day20_input.txt").unwrap();
    solve(2017, 20, 2, &input).unwrap();
}

fn problem_2017_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day21_input.txt").unwrap();
    solve(2017, 21, 1, &input).unwrap();
}

fn problem_2017_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day21_input.txt").unwrap();
    solve(2017, 21, 2, &input).unwrap();
}

fn problem_2017_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day22_input.txt").unwrap();
    solve(2017, 22, 1, &input).unwrap();
}

fn problem_2017_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day22_input.txt").unwrap();
    solve(2017, 22, 2, &input).unwrap();
}

fn problem_2017_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day23_input.txt").unwrap();
    solve(2017, 23, 1, &input).unwrap();
}

fn problem_2017_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day23_input.txt").unwrap();
    solve(2017, 23, 2, &input).unwrap();
}

fn problem_2017_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day24_input.txt").unwrap();
    solve(2017, 24, 1, &input).unwrap();
}

fn problem_2017_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day24_input.txt").unwrap();
    solve(2017, 24, 2, &input).unwrap();
}

fn problem_2017_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2017/day25_input.txt").unwrap();
    solve(2017, 25, 1, &input).unwrap();
}

fn problem_2018_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day01_input.txt").unwrap();
    solve(2018, 1, 1, &input).unwrap();
}

fn problem_2018_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day01_input.txt").unwrap();
    solve(2018, 1, 2, &input).unwrap();
}

fn problem_2018_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day02_input.txt").unwrap();
    solve(2018, 2, 1, &input).unwrap();
}

fn problem_2018_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day02_input.txt").unwrap();
    solve(2018, 2, 2, &input).unwrap();
}

fn problem_2018_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day03_input.txt").unwrap();
    solve(2018, 3, 1, &input).unwrap();
}

fn problem_2018_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day03_input.txt").unwrap();
    solve(2018, 3, 2, &input).unwrap();
}

fn problem_2018_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day04_input.txt").unwrap();
    solve(2018, 4, 1, &input).unwrap();
}

fn problem_2018_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day04_input.txt").unwrap();
    solve(2018, 4, 2, &input).unwrap();
}

fn problem_2018_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day05_input.txt").unwrap();
    solve(2018, 5, 1, &input).unwrap();
}

fn problem_2018_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day05_input.txt").unwrap();
    solve(2018, 5, 2, &input).unwrap();
}

fn problem_2018_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day06_input.txt").unwrap();
    solve(2018, 6, 1, &input).unwrap();
}

fn problem_2018_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day06_input.txt").unwrap();
    solve(2018, 6, 2, &input).unwrap();
}

fn problem_2018_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day07_input.txt").unwrap();
    solve(2018, 7, 1, &input).unwrap();
}

fn problem_2018_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day07_input.txt").unwrap();
    solve(2018, 7, 2, &input).unwrap();
}

fn problem_2018_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day08_input.txt").unwrap();
    solve(2018, 8, 1, &input).unwrap();
}

fn problem_2018_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day08_input.txt").unwrap();
    solve(2018, 8, 2, &input).unwrap();
}

fn problem_2018_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day09_input.txt").unwrap();
    solve(2018, 9, 1, &input).unwrap();
}

fn problem_2018_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day09_input.txt").unwrap();
    solve(2018, 9, 2, &input).unwrap();
}

fn problem_2018_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day10_input.txt").unwrap();
    solve(2018, 10, 1, &input).unwrap();
}

fn problem_2018_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day10_input.txt").unwrap();
    solve(2018, 10, 2, &input).unwrap();
}

fn problem_2018_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day11_input.txt").unwrap();
    solve(2018, 11, 1, &input).unwrap();
}

fn problem_2018_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day11_input.txt").unwrap();
    solve(2018, 11, 2, &input).unwrap();
}

fn problem_2018_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day12_input.txt").unwrap();
    solve(2018, 12, 1, &input).unwrap();
}

fn problem_2018_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day12_input.txt").unwrap();
    solve(2018, 12, 2, &input).unwrap();
}

fn problem_2018_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day13_input.txt").unwrap();
    solve(2018, 13, 1, &input).unwrap();
}

fn problem_2018_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day13_input.txt").unwrap();
    solve(2018, 13, 2, &input).unwrap();
}

fn problem_2018_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day14_input.txt").unwrap();
    solve(2018, 14, 1, &input).unwrap();
}

fn problem_2018_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day14_input.txt").unwrap();
    solve(2018, 14, 2, &input).unwrap();
}

fn problem_2018_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day15_input.txt").unwrap();
    solve(2018, 15, 1, &input).unwrap();
}

fn problem_2018_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day15_input.txt").unwrap();
    solve(2018, 15, 2, &input).unwrap();
}

fn problem_2018_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day16_input.txt").unwrap();
    solve(2018, 16, 1, &input).unwrap();
}

fn problem_2018_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day16_input.txt").unwrap();
    solve(2018, 16, 2, &input).unwrap();
}

fn problem_2018_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day17_input.txt").unwrap();
    solve(2018, 17, 1, &input).unwrap();
}

fn problem_2018_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day17_input.txt").unwrap();
    solve(2018, 17, 2, &input).unwrap();
}

fn problem_2018_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day18_input.txt").unwrap();
    solve(2018, 18, 1, &input).unwrap();
}

fn problem_2018_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day18_input.txt").unwrap();
    solve(2018, 18, 2, &input).unwrap();
}

fn problem_2018_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day19_input.txt").unwrap();
    solve(2018, 19, 1, &input).unwrap();
}

fn problem_2018_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day19_input.txt").unwrap();
    solve(2018, 19, 2, &input).unwrap();
}

fn problem_2018_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day20_input.txt").unwrap();
    solve(2018, 20, 1, &input).unwrap();
}

fn problem_2018_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day20_input.txt").unwrap();
    solve(2018, 20, 2, &input).unwrap();
}

fn problem_2018_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day21_input.txt").unwrap();
    solve(2018, 21, 1, &input).unwrap();
}

fn problem_2018_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day21_input.txt").unwrap();
    solve(2018, 21, 2, &input).unwrap();
}

fn problem_2018_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day22_input.txt").unwrap();
    solve(2018, 22, 1, &input).unwrap();
}

fn problem_2018_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day22_input.txt").unwrap();
    solve(2018, 22, 2, &input).unwrap();
}

fn problem_2018_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day23_input.txt").unwrap();
    solve(2018, 23, 1, &input).unwrap();
}

fn problem_2018_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day23_input.txt").unwrap();
    solve(2018, 23, 2, &input).unwrap();
}

fn problem_2018_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day24_input.txt").unwrap();
    solve(2018, 24, 1, &input).unwrap();
}

fn problem_2018_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day24_input.txt").unwrap();
    solve(2018, 24, 2, &input).unwrap();
}

fn problem_2018_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2018/day25_input.txt").unwrap();
    solve(2018, 25, 1, &input).unwrap();
}

fn problem_2019_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day01_input.txt").unwrap();
    solve(2019, 1, 1, &input).unwrap();
}

fn problem_2019_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day01_input.txt").unwrap();
    solve(2019, 1, 2, &input).unwrap();
}

fn problem_2019_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day02_input.txt").unwrap();
    solve(2019, 2, 1, &input).unwrap();
}

fn problem_2019_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day02_input.txt").unwrap();
    solve(2019, 2, 2, &input).unwrap();
}

fn problem_2019_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day03_input.txt").unwrap();
    solve(2019, 3, 1, &input).unwrap();
}

fn problem_2019_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day03_input.txt").unwrap();
    solve(2019, 3, 2, &input).unwrap();
}

fn problem_2019_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day04_input.txt").unwrap();
    solve(2019, 4, 1, &input).unwrap();
}

fn problem_2019_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day04_input.txt").unwrap();
    solve(2019, 4, 2, &input).unwrap();
}

fn problem_2019_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day05_input.txt").unwrap();
    solve(2019, 5, 1, &input).unwrap();
}

fn problem_2019_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day05_input.txt").unwrap();
    solve(2019, 5, 2, &input).unwrap();
}

fn problem_2019_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day06_input.txt").unwrap();
    solve(2019, 6, 1, &input).unwrap();
}

fn problem_2019_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day06_input.txt").unwrap();
    solve(2019, 6, 2, &input).unwrap();
}

fn problem_2019_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day07_input.txt").unwrap();
    solve(2019, 7, 1, &input).unwrap();
}

fn problem_2019_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day07_input.txt").unwrap();
    solve(2019, 7, 2, &input).unwrap();
}

fn problem_2019_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day08_input.txt").unwrap();
    solve(2019, 8, 1, &input).unwrap();
}

fn problem_2019_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day08_input.txt").unwrap();
    solve(2019, 8, 2, &input).unwrap();
}

fn problem_2019_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day09_input.txt").unwrap();
    solve(2019, 9, 1, &input).unwrap();
}

fn problem_2019_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day09_input.txt").unwrap();
    solve(2019, 9, 2, &input).unwrap();
}

fn problem_2019_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day10_input.txt").unwrap();
    solve(2019, 10, 1, &input).unwrap();
}

fn problem_2019_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day10_input.txt").unwrap();
    solve(2019, 10, 2, &input).unwrap();
}

fn problem_2019_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day11_input.txt").unwrap();
    solve(2019, 11, 1, &input).unwrap();
}

fn problem_2019_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day11_input.txt").unwrap();
    solve(2019, 11, 2, &input).unwrap();
}

fn problem_2019_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day12_input.txt").unwrap();
    solve(2019, 12, 1, &input).unwrap();
}

fn problem_2019_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day12_input.txt").unwrap();
    solve(2019, 12, 2, &input).unwrap();
}

fn problem_2019_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day13_input.txt").unwrap();
    solve(2019, 13, 1, &input).unwrap();
}

fn problem_2019_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day13_input.txt").unwrap();
    solve(2019, 13, 2, &input).unwrap();
}

fn problem_2019_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day14_input.txt").unwrap();
    solve(2019, 14, 1, &input).unwrap();
}

fn problem_2019_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day14_input.txt").unwrap();
    solve(2019, 14, 2, &input).unwrap();
}

fn problem_2019_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day15_input.txt").unwrap();
    solve(2019, 15, 1, &input).unwrap();
}

fn problem_2019_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day15_input.txt").unwrap();
    solve(2019, 15, 2, &input).unwrap();
}

fn problem_2019_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day16_input.txt").unwrap();
    solve(2019, 16, 1, &input).unwrap();
}

fn problem_2019_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day16_input.txt").unwrap();
    solve(2019, 16, 2, &input).unwrap();
}

fn problem_2019_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day17_input.txt").unwrap();
    solve(2019, 17, 1, &input).unwrap();
}

fn problem_2019_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day17_input.txt").unwrap();
    solve(2019, 17, 2, &input).unwrap();
}

fn problem_2019_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day18_input.txt").unwrap();
    solve(2019, 18, 1, &input).unwrap();
}

fn problem_2019_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day18_input.txt").unwrap();
    solve(2019, 18, 2, &input).unwrap();
}

fn problem_2019_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day19_input.txt").unwrap();
    solve(2019, 19, 1, &input).unwrap();
}

fn problem_2019_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day19_input.txt").unwrap();
    solve(2019, 19, 2, &input).unwrap();
}

fn problem_2019_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day20_input.txt").unwrap();
    solve(2019, 20, 1, &input).unwrap();
}

fn problem_2019_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day20_input.txt").unwrap();
    solve(2019, 20, 2, &input).unwrap();
}

fn problem_2019_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day21_input.txt").unwrap();
    solve(2019, 21, 1, &input).unwrap();
}

fn problem_2019_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day21_input.txt").unwrap();
    solve(2019, 21, 2, &input).unwrap();
}

fn problem_2019_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day22_input.txt").unwrap();
    solve(2019, 22, 1, &input).unwrap();
}

fn problem_2019_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day22_input.txt").unwrap();
    solve(2019, 22, 2, &input).unwrap();
}

fn problem_2019_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day23_input.txt").unwrap();
    solve(2019, 23, 1, &input).unwrap();
}

fn problem_2019_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day23_input.txt").unwrap();
    solve(2019, 23, 2, &input).unwrap();
}

fn problem_2019_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day24_input.txt").unwrap();
    solve(2019, 24, 1, &input).unwrap();
}

fn problem_2019_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day24_input.txt").unwrap();
    solve(2019, 24, 2, &input).unwrap();
}

fn problem_2019_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2019/day25_input.txt").unwrap();
    solve(2019, 25, 1, &input).unwrap();
}

fn problem_2020_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day01_input.txt").unwrap();
    solve(2020, 1, 1, &input).unwrap();
}

fn problem_2020_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day01_input.txt").unwrap();
    solve(2020, 1, 2, &input).unwrap();
}

fn problem_2020_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day02_input.txt").unwrap();
    solve(2020, 2, 1, &input).unwrap();
}

fn problem_2020_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day02_input.txt").unwrap();
    solve(2020, 2, 2, &input).unwrap();
}

fn problem_2020_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day03_input.txt").unwrap();
    solve(2020, 3, 1, &input).unwrap();
}

fn problem_2020_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day03_input.txt").unwrap();
    solve(2020, 3, 2, &input).unwrap();
}

fn problem_2020_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day04_input.txt").unwrap();
    solve(2020, 4, 1, &input).unwrap();
}

fn problem_2020_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day04_input.txt").unwrap();
    solve(2020, 4, 2, &input).unwrap();
}

fn problem_2020_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day05_input.txt").unwrap();
    solve(2020, 5, 1, &input).unwrap();
}

fn problem_2020_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day05_input.txt").unwrap();
    solve(2020, 5, 2, &input).unwrap();
}

fn problem_2020_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day06_input.txt").unwrap();
    solve(2020, 6, 1, &input).unwrap();
}

fn problem_2020_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day06_input.txt").unwrap();
    solve(2020, 6, 2, &input).unwrap();
}

fn problem_2020_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day07_input.txt").unwrap();
    solve(2020, 7, 1, &input).unwrap();
}

fn problem_2020_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day07_input.txt").unwrap();
    solve(2020, 7, 2, &input).unwrap();
}

fn problem_2020_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day08_input.txt").unwrap();
    solve(2020, 8, 1, &input).unwrap();
}

fn problem_2020_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day08_input.txt").unwrap();
    solve(2020, 8, 2, &input).unwrap();
}

fn problem_2020_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day09_input.txt").unwrap();
    solve(2020, 9, 1, &input).unwrap();
}

fn problem_2020_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day09_input.txt").unwrap();
    solve(2020, 9, 2, &input).unwrap();
}

fn problem_2020_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day10_input.txt").unwrap();
    solve(2020, 10, 1, &input).unwrap();
}

fn problem_2020_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day10_input.txt").unwrap();
    solve(2020, 10, 2, &input).unwrap();
}

fn problem_2020_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day11_input.txt").unwrap();
    solve(2020, 11, 1, &input).unwrap();
}

fn problem_2020_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day11_input.txt").unwrap();
    solve(2020, 11, 2, &input).unwrap();
}

fn problem_2020_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day12_input.txt").unwrap();
    solve(2020, 12, 1, &input).unwrap();
}

fn problem_2020_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day12_input.txt").unwrap();
    solve(2020, 12, 2, &input).unwrap();
}

fn problem_2020_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day13_input.txt").unwrap();
    solve(2020, 13, 1, &input).unwrap();
}

fn problem_2020_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day13_input.txt").unwrap();
    solve(2020, 13, 2, &input).unwrap();
}

fn problem_2020_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day14_input.txt").unwrap();
    solve(2020, 14, 1, &input).unwrap();
}

fn problem_2020_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day14_input.txt").unwrap();
    solve(2020, 14, 2, &input).unwrap();
}

fn problem_2020_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day15_input.txt").unwrap();
    solve(2020, 15, 1, &input).unwrap();
}

fn problem_2020_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day15_input.txt").unwrap();
    solve(2020, 15, 2, &input).unwrap();
}

fn problem_2020_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day16_input.txt").unwrap();
    solve(2020, 16, 1, &input).unwrap();
}

fn problem_2020_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day16_input.txt").unwrap();
    solve(2020, 16, 2, &input).unwrap();
}

fn problem_2020_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day17_input.txt").unwrap();
    solve(2020, 17, 1, &input).unwrap();
}

fn problem_2020_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day17_input.txt").unwrap();
    solve(2020, 17, 2, &input).unwrap();
}

fn problem_2020_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day18_input.txt").unwrap();
    solve(2020, 18, 1, &input).unwrap();
}

fn problem_2020_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day18_input.txt").unwrap();
    solve(2020, 18, 2, &input).unwrap();
}

fn problem_2020_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day19_input.txt").unwrap();
    solve(2020, 19, 1, &input).unwrap();
}

fn problem_2020_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day19_input.txt").unwrap();
    solve(2020, 19, 2, &input).unwrap();
}

fn problem_2020_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day20_input.txt").unwrap();
    solve(2020, 20, 1, &input).unwrap();
}

fn problem_2020_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day20_input.txt").unwrap();
    solve(2020, 20, 2, &input).unwrap();
}

fn problem_2020_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day21_input.txt").unwrap();
    solve(2020, 21, 1, &input).unwrap();
}

fn problem_2020_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day21_input.txt").unwrap();
    solve(2020, 21, 2, &input).unwrap();
}

fn problem_2020_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day22_input.txt").unwrap();
    solve(2020, 22, 1, &input).unwrap();
}

fn problem_2020_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day22_input.txt").unwrap();
    solve(2020, 22, 2, &input).unwrap();
}

fn problem_2020_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day23_input.txt").unwrap();
    solve(2020, 23, 1, &input).unwrap();
}

fn problem_2020_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day23_input.txt").unwrap();
    solve(2020, 23, 2, &input).unwrap();
}

fn problem_2020_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day24_input.txt").unwrap();
    solve(2020, 24, 1, &input).unwrap();
}

fn problem_2020_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day24_input.txt").unwrap();
    solve(2020, 24, 2, &input).unwrap();
}

fn problem_2020_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2020/day25_input.txt").unwrap();
    solve(2020, 25, 1, &input).unwrap();
}

fn problem_2021_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day01_input.txt").unwrap();
    solve(2021, 1, 1, &input).unwrap();
}

fn problem_2021_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day01_input.txt").unwrap();
    solve(2021, 1, 2, &input).unwrap();
}

fn problem_2021_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day02_input.txt").unwrap();
    solve(2021, 2, 1, &input).unwrap();
}

fn problem_2021_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day02_input.txt").unwrap();
    solve(2021, 2, 2, &input).unwrap();
}

fn problem_2021_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day03_input.txt").unwrap();
    solve(2021, 3, 1, &input).unwrap();
}

fn problem_2021_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day03_input.txt").unwrap();
    solve(2021, 3, 2, &input).unwrap();
}

fn problem_2021_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day04_input.txt").unwrap();
    solve(2021, 4, 1, &input).unwrap();
}

fn problem_2021_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day04_input.txt").unwrap();
    solve(2021, 4, 2, &input).unwrap();
}

fn problem_2021_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day05_input.txt").unwrap();
    solve(2021, 5, 1, &input).unwrap();
}

fn problem_2021_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day05_input.txt").unwrap();
    solve(2021, 5, 2, &input).unwrap();
}

fn problem_2021_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day06_input.txt").unwrap();
    solve(2021, 6, 1, &input).unwrap();
}

fn problem_2021_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day06_input.txt").unwrap();
    solve(2021, 6, 2, &input).unwrap();
}

fn problem_2021_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day07_input.txt").unwrap();
    solve(2021, 7, 1, &input).unwrap();
}

fn problem_2021_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day07_input.txt").unwrap();
    solve(2021, 7, 2, &input).unwrap();
}

fn problem_2021_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day08_input.txt").unwrap();
    solve(2021, 8, 1, &input).unwrap();
}

fn problem_2021_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day08_input.txt").unwrap();
    solve(2021, 8, 2, &input).unwrap();
}

fn problem_2021_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day09_input.txt").unwrap();
    solve(2021, 9, 1, &input).unwrap();
}

fn problem_2021_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day09_input.txt").unwrap();
    solve(2021, 9, 2, &input).unwrap();
}

fn problem_2021_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day10_input.txt").unwrap();
    solve(2021, 10, 1, &input).unwrap();
}

fn problem_2021_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day10_input.txt").unwrap();
    solve(2021, 10, 2, &input).unwrap();
}

fn problem_2021_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day11_input.txt").unwrap();
    solve(2021, 11, 1, &input).unwrap();
}

fn problem_2021_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day11_input.txt").unwrap();
    solve(2021, 11, 2, &input).unwrap();
}

fn problem_2021_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day12_input.txt").unwrap();
    solve(2021, 12, 1, &input).unwrap();
}

fn problem_2021_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day12_input.txt").unwrap();
    solve(2021, 12, 2, &input).unwrap();
}

fn problem_2021_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day13_input.txt").unwrap();
    solve(2021, 13, 1, &input).unwrap();
}

fn problem_2021_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day13_input.txt").unwrap();
    solve(2021, 13, 2, &input).unwrap();
}

fn problem_2021_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day14_input.txt").unwrap();
    solve(2021, 14, 1, &input).unwrap();
}

fn problem_2021_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day14_input.txt").unwrap();
    solve(2021, 14, 2, &input).unwrap();
}

fn problem_2021_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day15_input.txt").unwrap();
    solve(2021, 15, 1, &input).unwrap();
}

fn problem_2021_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day15_input.txt").unwrap();
    solve(2021, 15, 2, &input).unwrap();
}

fn problem_2021_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day16_input.txt").unwrap();
    solve(2021, 16, 1, &input).unwrap();
}

fn problem_2021_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day16_input.txt").unwrap();
    solve(2021, 16, 2, &input).unwrap();
}

fn problem_2021_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day17_input.txt").unwrap();
    solve(2021, 17, 1, &input).unwrap();
}

fn problem_2021_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day17_input.txt").unwrap();
    solve(2021, 17, 2, &input).unwrap();
}

fn problem_2021_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day18_input.txt").unwrap();
    solve(2021, 18, 1, &input).unwrap();
}

fn problem_2021_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day18_input.txt").unwrap();
    solve(2021, 18, 2, &input).unwrap();
}

fn problem_2021_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day19_input.txt").unwrap();
    solve(2021, 19, 1, &input).unwrap();
}

fn problem_2021_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day19_input.txt").unwrap();
    solve(2021, 19, 2, &input).unwrap();
}

fn problem_2021_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day20_input.txt").unwrap();
    solve(2021, 20, 1, &input).unwrap();
}

fn problem_2021_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day20_input.txt").unwrap();
    solve(2021, 20, 2, &input).unwrap();
}

fn problem_2021_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day21_input.txt").unwrap();
    solve(2021, 21, 1, &input).unwrap();
}

fn problem_2021_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day21_input.txt").unwrap();
    solve(2021, 21, 2, &input).unwrap();
}

fn problem_2021_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day22_input.txt").unwrap();
    solve(2021, 22, 1, &input).unwrap();
}

fn problem_2021_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day22_input.txt").unwrap();
    solve(2021, 22, 2, &input).unwrap();
}

fn problem_2021_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day23_input.txt").unwrap();
    solve(2021, 23, 1, &input).unwrap();
}

fn problem_2021_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day23_input.txt").unwrap();
    solve(2021, 23, 2, &input).unwrap();
}

fn problem_2021_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day24_input.txt").unwrap();
    solve(2021, 24, 1, &input).unwrap();
}

fn problem_2021_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day24_input.txt").unwrap();
    solve(2021, 24, 2, &input).unwrap();
}

fn problem_2021_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2021/day25_input.txt").unwrap();
    solve(2021, 25, 1, &input).unwrap();
}

fn problem_2022_1_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day01_input.txt").unwrap();
    solve(2022, 1, 1, &input).unwrap();
}

fn problem_2022_1_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day01_input.txt").unwrap();
    solve(2022, 1, 2, &input).unwrap();
}

fn problem_2022_2_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day02_input.txt").unwrap();
    solve(2022, 2, 1, &input).unwrap();
}

fn problem_2022_2_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day02_input.txt").unwrap();
    solve(2022, 2, 2, &input).unwrap();
}

fn problem_2022_3_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day03_input.txt").unwrap();
    solve(2022, 3, 1, &input).unwrap();
}

fn problem_2022_3_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day03_input.txt").unwrap();
    solve(2022, 3, 2, &input).unwrap();
}

fn problem_2022_4_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day04_input.txt").unwrap();
    solve(2022, 4, 1, &input).unwrap();
}

fn problem_2022_4_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day04_input.txt").unwrap();
    solve(2022, 4, 2, &input).unwrap();
}

fn problem_2022_5_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day05_input.txt").unwrap();
    solve(2022, 5, 1, &input).unwrap();
}

fn problem_2022_5_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day05_input.txt").unwrap();
    solve(2022, 5, 2, &input).unwrap();
}

fn problem_2022_6_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day06_input.txt").unwrap();
    solve(2022, 6, 1, &input).unwrap();
}

fn problem_2022_6_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day06_input.txt").unwrap();
    solve(2022, 6, 2, &input).unwrap();
}

fn problem_2022_7_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day07_input.txt").unwrap();
    solve(2022, 7, 1, &input).unwrap();
}

fn problem_2022_7_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day07_input.txt").unwrap();
    solve(2022, 7, 2, &input).unwrap();
}

fn problem_2022_8_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day08_input.txt").unwrap();
    solve(2022, 8, 1, &input).unwrap();
}

fn problem_2022_8_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day08_input.txt").unwrap();
    solve(2022, 8, 2, &input).unwrap();
}

fn problem_2022_9_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day09_input.txt").unwrap();
    solve(2022, 9, 1, &input).unwrap();
}

fn problem_2022_9_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day09_input.txt").unwrap();
    solve(2022, 9, 2, &input).unwrap();
}

fn problem_2022_10_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day10_input.txt").unwrap();
    solve(2022, 10, 1, &input).unwrap();
}

fn problem_2022_10_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day10_input.txt").unwrap();
    solve(2022, 10, 2, &input).unwrap();
}

fn problem_2022_11_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day11_input.txt").unwrap();
    solve(2022, 11, 1, &input).unwrap();
}

fn problem_2022_11_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day11_input.txt").unwrap();
    solve(2022, 11, 2, &input).unwrap();
}

fn problem_2022_12_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day12_input.txt").unwrap();
    solve(2022, 12, 1, &input).unwrap();
}

fn problem_2022_12_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day12_input.txt").unwrap();
    solve(2022, 12, 2, &input).unwrap();
}

fn problem_2022_13_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day13_input.txt").unwrap();
    solve(2022, 13, 1, &input).unwrap();
}

fn problem_2022_13_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day13_input.txt").unwrap();
    solve(2022, 13, 2, &input).unwrap();
}

fn problem_2022_14_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day14_input.txt").unwrap();
    solve(2022, 14, 1, &input).unwrap();
}

fn problem_2022_14_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day14_input.txt").unwrap();
    solve(2022, 14, 2, &input).unwrap();
}

fn problem_2022_15_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day15_input.txt").unwrap();
    solve(2022, 15, 1, &input).unwrap();
}

fn problem_2022_15_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day15_input.txt").unwrap();
    solve(2022, 15, 2, &input).unwrap();
}

fn problem_2022_16_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day16_input.txt").unwrap();
    solve(2022, 16, 1, &input).unwrap();
}

fn problem_2022_16_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day16_input.txt").unwrap();
    solve(2022, 16, 2, &input).unwrap();
}

fn problem_2022_17_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day17_input.txt").unwrap();
    solve(2022, 17, 1, &input).unwrap();
}

fn problem_2022_17_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day17_input.txt").unwrap();
    solve(2022, 17, 2, &input).unwrap();
}

fn problem_2022_18_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day18_input.txt").unwrap();
    solve(2022, 18, 1, &input).unwrap();
}

fn problem_2022_18_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day18_input.txt").unwrap();
    solve(2022, 18, 2, &input).unwrap();
}

fn problem_2022_19_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day19_input.txt").unwrap();
    solve(2022, 19, 1, &input).unwrap();
}

fn problem_2022_19_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day19_input.txt").unwrap();
    solve(2022, 19, 2, &input).unwrap();
}

fn problem_2022_20_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day20_input.txt").unwrap();
    solve(2022, 20, 1, &input).unwrap();
}

fn problem_2022_20_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day20_input.txt").unwrap();
    solve(2022, 20, 2, &input).unwrap();
}

fn problem_2022_21_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day21_input.txt").unwrap();
    solve(2022, 21, 1, &input).unwrap();
}

fn problem_2022_21_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day21_input.txt").unwrap();
    solve(2022, 21, 2, &input).unwrap();
}

fn problem_2022_22_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day22_input.txt").unwrap();
    solve(2022, 22, 1, &input).unwrap();
}

fn problem_2022_22_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day22_input.txt").unwrap();
    solve(2022, 22, 2, &input).unwrap();
}

fn problem_2022_23_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day23_input.txt").unwrap();
    solve(2022, 23, 1, &input).unwrap();
}

fn problem_2022_23_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day23_input.txt").unwrap();
    solve(2022, 23, 2, &input).unwrap();
}

fn problem_2022_24_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day24_input.txt").unwrap();
    solve(2022, 24, 1, &input).unwrap();
}

fn problem_2022_24_2() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day24_input.txt").unwrap();
    solve(2022, 24, 2, &input).unwrap();
}

fn problem_2022_25_1() {
    #![allow(clippy::unwrap_used)]
    let input = read_to_string("src/year2022/day25_input.txt").unwrap();
    solve(2022, 25, 1, &input).unwrap();
}

iai::main!(
    problem_2015_1_1,
    problem_2015_1_2,
    problem_2015_2_1,
    problem_2015_2_2,
    problem_2015_3_1,
    problem_2015_3_2,
    problem_2015_4_1,
    problem_2015_4_2,
    problem_2015_5_1,
    problem_2015_5_2,
    problem_2015_6_1,
    problem_2015_6_2,
    problem_2015_7_1,
    problem_2015_7_2,
    problem_2015_8_1,
    problem_2015_8_2,
    problem_2015_9_1,
    problem_2015_9_2,
    problem_2015_10_1,
    problem_2015_10_2,
    problem_2015_11_1,
    problem_2015_11_2,
    problem_2015_12_1,
    problem_2015_12_2,
    problem_2015_13_1,
    problem_2015_13_2,
    problem_2015_14_1,
    problem_2015_14_2,
    problem_2015_15_1,
    problem_2015_15_2,
    problem_2015_16_1,
    problem_2015_16_2,
    problem_2015_17_1,
    problem_2015_17_2,
    problem_2015_18_1,
    problem_2015_18_2,
    problem_2015_19_1,
    problem_2015_19_2,
    problem_2015_20_1,
    problem_2015_20_2,
    problem_2015_21_1,
    problem_2015_21_2,
    problem_2015_22_1,
    problem_2015_22_2,
    problem_2015_23_1,
    problem_2015_23_2,
    problem_2015_24_1,
    problem_2015_24_2,
    problem_2015_25_1,
    problem_2016_1_1,
    problem_2016_1_2,
    problem_2016_2_1,
    problem_2016_2_2,
    problem_2016_3_1,
    problem_2016_3_2,
    problem_2016_4_1,
    problem_2016_4_2,
    problem_2016_5_1,
    problem_2016_5_2,
    problem_2016_6_1,
    problem_2016_6_2,
    problem_2016_7_1,
    problem_2016_7_2,
    problem_2016_8_1,
    problem_2016_8_2,
    problem_2016_9_1,
    problem_2016_9_2,
    problem_2016_10_1,
    problem_2016_10_2,
    problem_2016_11_1,
    problem_2016_11_2,
    problem_2016_12_1,
    problem_2016_12_2,
    problem_2016_13_1,
    problem_2016_13_2,
    problem_2016_14_1,
    problem_2016_14_2,
    problem_2016_15_1,
    problem_2016_15_2,
    problem_2016_16_1,
    problem_2016_16_2,
    problem_2016_17_1,
    problem_2016_17_2,
    problem_2016_18_1,
    problem_2016_18_2,
    problem_2016_19_1,
    problem_2016_19_2,
    problem_2016_20_1,
    problem_2016_20_2,
    problem_2016_21_1,
    problem_2016_21_2,
    problem_2016_22_1,
    problem_2016_22_2,
    problem_2016_23_1,
    problem_2016_23_2,
    problem_2016_24_1,
    problem_2016_24_2,
    problem_2016_25_1,
    problem_2017_1_1,
    problem_2017_1_2,
    problem_2017_2_1,
    problem_2017_2_2,
    problem_2017_3_1,
    problem_2017_3_2,
    problem_2017_4_1,
    problem_2017_4_2,
    problem_2017_5_1,
    problem_2017_5_2,
    problem_2017_6_1,
    problem_2017_6_2,
    problem_2017_7_1,
    problem_2017_7_2,
    problem_2017_8_1,
    problem_2017_8_2,
    problem_2017_9_1,
    problem_2017_9_2,
    problem_2017_10_1,
    problem_2017_10_2,
    problem_2017_11_1,
    problem_2017_11_2,
    problem_2017_12_1,
    problem_2017_12_2,
    problem_2017_13_1,
    problem_2017_13_2,
    problem_2017_14_1,
    problem_2017_14_2,
    problem_2017_15_1,
    problem_2017_15_2,
    problem_2017_16_1,
    problem_2017_16_2,
    problem_2017_17_1,
    problem_2017_17_2,
    problem_2017_18_1,
    problem_2017_18_2,
    problem_2017_19_1,
    problem_2017_19_2,
    problem_2017_20_1,
    problem_2017_20_2,
    problem_2017_21_1,
    problem_2017_21_2,
    problem_2017_22_1,
    problem_2017_22_2,
    problem_2017_23_1,
    problem_2017_23_2,
    problem_2017_24_1,
    problem_2017_24_2,
    problem_2017_25_1,
    problem_2018_1_1,
    problem_2018_1_2,
    problem_2018_2_1,
    problem_2018_2_2,
    problem_2018_3_1,
    problem_2018_3_2,
    problem_2018_4_1,
    problem_2018_4_2,
    problem_2018_5_1,
    problem_2018_5_2,
    problem_2018_6_1,
    problem_2018_6_2,
    problem_2018_7_1,
    problem_2018_7_2,
    problem_2018_8_1,
    problem_2018_8_2,
    problem_2018_9_1,
    problem_2018_9_2,
    problem_2018_10_1,
    problem_2018_10_2,
    problem_2018_11_1,
    problem_2018_11_2,
    problem_2018_12_1,
    problem_2018_12_2,
    problem_2018_13_1,
    problem_2018_13_2,
    problem_2018_14_1,
    problem_2018_14_2,
    problem_2018_15_1,
    problem_2018_15_2,
    problem_2018_16_1,
    problem_2018_16_2,
    problem_2018_17_1,
    problem_2018_17_2,
    problem_2018_18_1,
    problem_2018_18_2,
    problem_2018_19_1,
    problem_2018_19_2,
    problem_2018_20_1,
    problem_2018_20_2,
    problem_2018_21_1,
    problem_2018_21_2,
    problem_2018_22_1,
    problem_2018_22_2,
    problem_2018_23_1,
    problem_2018_23_2,
    problem_2018_24_1,
    problem_2018_24_2,
    problem_2018_25_1,
    problem_2019_1_1,
    problem_2019_1_2,
    problem_2019_2_1,
    problem_2019_2_2,
    problem_2019_3_1,
    problem_2019_3_2,
    problem_2019_4_1,
    problem_2019_4_2,
    problem_2019_5_1,
    problem_2019_5_2,
    problem_2019_6_1,
    problem_2019_6_2,
    problem_2019_7_1,
    problem_2019_7_2,
    problem_2019_8_1,
    problem_2019_8_2,
    problem_2019_9_1,
    problem_2019_9_2,
    problem_2019_10_1,
    problem_2019_10_2,
    problem_2019_11_1,
    problem_2019_11_2,
    problem_2019_12_1,
    problem_2019_12_2,
    problem_2019_13_1,
    problem_2019_13_2,
    problem_2019_14_1,
    problem_2019_14_2,
    problem_2019_15_1,
    problem_2019_15_2,
    problem_2019_16_1,
    problem_2019_16_2,
    problem_2019_17_1,
    problem_2019_17_2,
    problem_2019_18_1,
    problem_2019_18_2,
    problem_2019_19_1,
    problem_2019_19_2,
    problem_2019_20_1,
    problem_2019_20_2,
    problem_2019_21_1,
    problem_2019_21_2,
    problem_2019_22_1,
    problem_2019_22_2,
    problem_2019_23_1,
    problem_2019_23_2,
    problem_2019_24_1,
    problem_2019_24_2,
    problem_2019_25_1,
    problem_2020_1_1,
    problem_2020_1_2,
    problem_2020_2_1,
    problem_2020_2_2,
    problem_2020_3_1,
    problem_2020_3_2,
    problem_2020_4_1,
    problem_2020_4_2,
    problem_2020_5_1,
    problem_2020_5_2,
    problem_2020_6_1,
    problem_2020_6_2,
    problem_2020_7_1,
    problem_2020_7_2,
    problem_2020_8_1,
    problem_2020_8_2,
    problem_2020_9_1,
    problem_2020_9_2,
    problem_2020_10_1,
    problem_2020_10_2,
    problem_2020_11_1,
    problem_2020_11_2,
    problem_2020_12_1,
    problem_2020_12_2,
    problem_2020_13_1,
    problem_2020_13_2,
    problem_2020_14_1,
    problem_2020_14_2,
    problem_2020_15_1,
    problem_2020_15_2,
    problem_2020_16_1,
    problem_2020_16_2,
    problem_2020_17_1,
    problem_2020_17_2,
    problem_2020_18_1,
    problem_2020_18_2,
    problem_2020_19_1,
    problem_2020_19_2,
    problem_2020_20_1,
    problem_2020_20_2,
    problem_2020_21_1,
    problem_2020_21_2,
    problem_2020_22_1,
    problem_2020_22_2,
    problem_2020_23_1,
    problem_2020_23_2,
    problem_2020_24_1,
    problem_2020_24_2,
    problem_2020_25_1,
    problem_2021_1_1,
    problem_2021_1_2,
    problem_2021_2_1,
    problem_2021_2_2,
    problem_2021_3_1,
    problem_2021_3_2,
    problem_2021_4_1,
    problem_2021_4_2,
    problem_2021_5_1,
    problem_2021_5_2,
    problem_2021_6_1,
    problem_2021_6_2,
    problem_2021_7_1,
    problem_2021_7_2,
    problem_2021_8_1,
    problem_2021_8_2,
    problem_2021_9_1,
    problem_2021_9_2,
    problem_2021_10_1,
    problem_2021_10_2,
    problem_2021_11_1,
    problem_2021_11_2,
    problem_2021_12_1,
    problem_2021_12_2,
    problem_2021_13_1,
    problem_2021_13_2,
    problem_2021_14_1,
    problem_2021_14_2,
    problem_2021_15_1,
    problem_2021_15_2,
    problem_2021_16_1,
    problem_2021_16_2,
    problem_2021_17_1,
    problem_2021_17_2,
    problem_2021_18_1,
    problem_2021_18_2,
    problem_2021_19_1,
    problem_2021_19_2,
    problem_2021_20_1,
    problem_2021_20_2,
    problem_2021_21_1,
    problem_2021_21_2,
    problem_2021_22_1,
    problem_2021_22_2,
    problem_2021_23_1,
    problem_2021_23_2,
    problem_2021_24_1,
    problem_2021_24_2,
    problem_2021_25_1,
    problem_2022_1_1,
    problem_2022_1_2,
    problem_2022_2_1,
    problem_2022_2_2,
    problem_2022_3_1,
    problem_2022_3_2,
    problem_2022_4_1,
    problem_2022_4_2,
    problem_2022_5_1,
    problem_2022_5_2,
    problem_2022_6_1,
    problem_2022_6_2,
    problem_2022_7_1,
    problem_2022_7_2,
    problem_2022_8_1,
    problem_2022_8_2,
    problem_2022_9_1,
    problem_2022_9_2,
    problem_2022_10_1,
    problem_2022_10_2,
    problem_2022_11_1,
    problem_2022_11_2,
    problem_2022_12_1,
    problem_2022_12_2,
    problem_2022_13_1,
    problem_2022_13_2,
    problem_2022_14_1,
    problem_2022_14_2,
    problem_2022_15_1,
    problem_2022_15_2,
    problem_2022_16_1,
    problem_2022_16_2,
    problem_2022_17_1,
    problem_2022_17_2,
    problem_2022_18_1,
    problem_2022_18_2,
    problem_2022_19_1,
    problem_2022_19_2,
    problem_2022_20_1,
    problem_2022_20_2,
    problem_2022_21_1,
    problem_2022_21_2,
    problem_2022_22_1,
    problem_2022_22_2,
    problem_2022_23_1,
    problem_2022_23_2,
    problem_2022_24_1,
    problem_2022_24_2,
    problem_2022_25_1
);