2025 day06 p2

2025 day 05 p2
2025 day 07 p1
2025-12-14 22:04:04 +01:00 · 2025-12-14 20:43:34 +01:00 · 2025-12-14 18:43:39 +01:00 · 2025-12-14 17:39:21 +01:00 · 2025-12-14 14:37:38 +01:00 · 2025-12-14 12:43:52 +01:00
42 changed files with 1446 additions and 4693 deletions
--- a/2025/CMakeLists.txt
+++ b/2025/CMakeLists.txt
@@ -0,0 +1,38 @@
 find_package(fmt REQUIRED)
 find_package(utf8cpp REQUIRED)
 find_package(ctre REQUIRED)
 function(add_day_executables)
    foreach(src IN LISTS ARGN)
        get_filename_component(name "${src}" NAME_WE)
        add_executable(${name} "${src}")
        target_include_directories(${name} PUBLIC "${PROJECT_SOURCE_DIR}")
        target_compile_features(${name} PRIVATE cxx_std_23)
        target_link_libraries(${name}
            PRIVATE
                ${PLATFORM_LINK_LIBRARIES}
                fmt
                utf8cpp
                ctre
        )
        target_compile_definitions(${name} PRIVATE ${PLATFORM_DEFINITIONS})
        target_compile_options(${name} PRIVATE ${BASE_OPTIONS})
        source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES "${src}")
    endforeach()
 endfunction()
 add_day_executables(
    "day01.cpp"
    "day02.cpp"
    "day03.cpp"
    "day04.cpp"
    "day05.cpp"
    "day06.cpp"
    "day07.cpp"
 )
--- a/2025/day01.cpp
+++ b/2025/day01.cpp
@@ -0,0 +1,127 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // simple pipe for std::string by value
 template <typename F>
 auto operator|(std::string s, F&& f) -> decltype(auto) {
    return std::forward<F>(f)(std::move(s));
 }
 auto ltrim(std::string s) -> std::string {
    s.erase(
        std::begin(s),
        std::find_if(s.begin(), s.end(), [](char ch) {
            return !std::isspace(static_cast<char>(ch));
        }));
    return s;
 }
 auto rtrim(std::string s) -> std::string {
    s.erase(
        std::find_if(s.rbegin(), s.rend(), [](char ch) {
            return !std::isspace(static_cast<char>(ch));
        }).base(),
        s.end());
    return s;
 }
 auto trim(std::string s) -> std::string {
    return ltrim(rtrim(std::move(s)));
 }
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 L68
 L30
 R48
 L5
 R60
 L55
 L1
 L99
 R14
 L82
 )";
 auto map_char_to_rotdir(char c) -> i32 {
    switch (c) {
        case 'L': return -1;
        case 'R':
        default:  return 1;
    }
 }
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = str | trim;
    auto rot_vec = str | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
            return i32(std::stoi(std::string{++std::begin(str), std::end(str)})) * map_char_to_rotdir(*std::begin(str));
        }) | std::ranges::to<std::vector>();
    i32 start = 50;
    i32 zero_cross = 0;
    // auto sum = std::ranges::fold_left(rot_vec, 0, [&](auto a, auto t) {
    //         auto const p = start;
    //         start = (100 + p - t) % 100;
    //
    //         zero_cross += (std::abs((p - t + 1) % 100) + std::abs(t)) / 100;
    //
    //         fmt::print("pos: {}, next: {}, t: {}\n", p, start, t);
    //
    //         if (start == 0) {
    //             a += 1;
    //         }
    //
    //         return a;
    //     });
    auto sum = std::ranges::fold_left(rot_vec, 0, [&](auto a, auto t) {
            auto const dir = t < 0 ? -1 : 1;
            auto const steps = std::abs(t);
            for (i32 i = 0; i < steps; ++i) {
                auto next = start + dir;
                if (next < 0) next = 99;
                next = next % 100;
                if (next % 100 == 0)
                    ++zero_cross;
                start = next;
            }
            if (start % 100 == 0) {
                ++a;
                if (zero_cross > 0)
                    zero_cross -= 1;
            }
            return a;
        });
    fmt::print("res: {}, {} sum = {}\n", sum, zero_cross, sum + zero_cross);
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day02.cpp
+++ b/2025/day02.cpp
@@ -0,0 +1,90 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 11-22,95-115,998-1012,1188511880-1188511890,222220-222224,
 1698522-1698528,446443-446449,38593856-38593862,565653-565659,
 824824821-824824827,2121212118-2121212124
 )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);
    auto ids_str = str | std::views::split(","sv) | std::views::transform([](auto const& str) {
        std::vector<u64> range{};
        range.resize(2);
        // std::ranges::transform(
        //     aoc::trim(std::string{std::begin(str), std::end(str)}) | std::views::split("-"sv),
        //     std::begin(range),
        //     [](auto const& value) {
        //         return aoc::trim(std::string{std::begin(value), std::end(value)});
        //  });
        std::ranges::transform(
            aoc::trim(std::string{std::begin(str), std::end(str)}) | std::views::split("-"sv),
            std::begin(range),
            [](auto const& value) {
                return u64(std::stoul(aoc::trim(std::string{std::begin(value), std::end(value)})));
         });
        return range;
    }) | std::ranges::to<std::vector>();
    auto is_valid_id = [](u64 id) {
        auto const str = fmt::format("{}", id);
        if (str.size() % 2 != 0) return true;
        bool is_invalid = true;
        for (usize i = 0; i < str.size() / 2; ++i) {
            if (str[i] != str[str.size() / 2 + i]) {
                is_invalid = false;
                continue;
            }
        }
        return !is_invalid;
    };
    u64 sum = 0;
    for (auto const& id : ids_str) {
        u64 const start = id[0];
        u64 const end = id[1];
        fmt::print("{} -> {}: ", id[0], id[1]);
        for (u64 i = start; i <= end; ++i) {
            if (!is_valid_id(i)) {
                fmt::print("{}, ", i);
                sum += i;
            }
        }
        fmt::print("\n");
    }
    fmt::print("res: {}\n", sum);
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day03.cpp
+++ b/2025/day03.cpp
@@ -0,0 +1,73 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 987654321111111
 811111111111119
 234234234234278
 818181911112111
 )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);
    fmt::print("INPUT\n");
    fmt::print("⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼\n");
    fmt::print("{}\n", str);
    fmt::print("{}\n", std::string(80, '-'));
    auto jolts_str = str | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
        return aoc::trim(std::string{std::begin(str), std::end(str)});
    }) | std::ranges::to<std::vector>();
    std::vector<u64> jolts{};
    jolts.reserve(jolts_str.size());
    for (auto const& jolt : jolts_str) {
        u64 largest = 0;
        for (usize i = 0; i < jolt.size(); ++i) {
            for (usize j = i + 1; j < jolt.size(); ++j) {
                auto const value = std::stoull(fmt::format("{}{}", jolt[i], jolt[j]));
                if (value > largest) largest = value;
            }
        }
        jolts.push_back(largest);
    }
    for (auto const& jolt : jolts) {
        fmt::print("{}\n", jolt);
    }
    auto sum = std::ranges::fold_left(jolts, u64(0), [&](auto a, auto v) {
        return a + v;
    });
    fmt::print("res: {}\n", sum);
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day04.cpp
+++ b/2025/day04.cpp
@@ -0,0 +1,83 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 ..@@.@@@@.
@@@.@.@.@@
@@@@@.@.@@
@.@@@@..@.
@@.@@@@.@@
 .@@@@@@@.@
 .@.@.@.@@@
@.@@@.@@@@
 .@@@@@@@@.
@.@.@@@.@.
 )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);
    fmt::print("INPUT\n");
    fmt::print("⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼\n");
    fmt::print("{}\n", str);
    fmt::print("{}\n", std::string(80, '-'));
    auto grid = str | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
        return aoc::trim(std::string{std::begin(str), std::end(str)}) |
            std::views::transform([](auto const& ch) { return ch; }) |
            std::ranges::to<std::vector>();
    }) | std::ranges::to<std::vector>();
    u64 access = 0;
    for (isize i = 0; i < isize(grid.size()); ++i) {
        for (isize j = 0; j < isize(grid[i].size()); ++j) {
            auto const v = grid[i][j];
            if (v == '.') continue;
            u64 sum = 0;
            if (i - 1 >= 0 && j - 1 >= 0 && grid[i - 1][j - 1] == '@') ++sum;
            if (i - 1 >= 0 && grid[i - 1][j] == '@') ++sum;
            if (i - 1 >= 0 && j + 1 < isize(grid[i].size()) && grid[i - 1][j + 1] == '@') ++sum;
            if (j - 1 >= 0 && grid[i][j - 1] == '@') ++sum;
            if (j + 1 < isize(grid[i].size()) && grid[i][j + 1] == '@') ++sum;
            if (i + 1 < isize(grid.size()) && j - 1 >= 0 && grid[i + 1][j - 1] == '@') ++sum;
            if (i + 1 < isize(grid.size()) && grid[i + 1][j] == '@') ++sum;
            if (i + 1 < isize(grid.size()) && j + 1 < isize(grid[i].size()) && grid[i + 1][j + 1] == '@') ++sum;
            if (sum < 4) {
                // fmt::print("{},{}: {}\n", i, j, sum);
                ++access;
            }
        }
    }
    fmt::print("res: {}\n", access);
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day05.cpp
+++ b/2025/day05.cpp
@@ -0,0 +1,153 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include <set>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 3-5
 10-14
 16-20
 12-18
 1
 5
 8
 11
 17
 32
 )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);
    auto id_spec = str | std::views::split("\r\n\r\n"sv) | std::views::transform([](auto const& str) {
        return aoc::trim({std::begin(str), std::end(str)});
    }) | std::ranges::to<std::vector>();
    if (id_spec.size() < 2) throw std::runtime_error("ID specification is not valid");
    auto id_range = id_spec[0] | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
        return std::ranges::fold_left(str | std::views::split("-"sv), std::vector<f64>{}, [](auto a, auto const& v) {
                a.push_back(std::stod(std::string({std::begin(v), std::end(v)})));
                return a;
            });
    }) | std::ranges::to<std::vector>();
    auto ids = id_spec[1] | std::views::split("\n"sv) | std::views::transform([](auto const& str) {
        return std::stod(std::string{std::begin(str), std::end(str)});
    }) | std::ranges::to<std::vector>();
    struct range {
        f64 start;
        f64 end;
    };
    // f64 sum = 0;
    // for (usize i = 0; i < ids.size(); ++i) {
    //     auto const id = ids[i];
    //     bool is_valid = false;
    //     for (usize j = 0; j < id_range.size(); ++j) {
    //         auto const a = id_range[j][0];
    //         auto const b = id_range[j][1];
    //
    //         if (id >= a && id <= b) {
    //             is_valid = true;
    //             break;
    //         }
    //     }
    //
    //     fmt::print("id: {} is {}\n", id, is_valid ? "valid" : "not valid");
    //
    //     if (is_valid) ++sum;
    // }
    std::vector<range> range_vec{};
    for (usize i = 0; i < id_range.size(); ++i) {
        auto const a = id_range[i][0];
        auto const b = id_range[i][1];
        range_vec.push_back({a, b});
    }
    std::ranges::sort(range_vec, [](auto a, auto b) {
        return a.start < b.start;
    });
    fmt::print("----------\n");
    // for (auto const& r : range_vec) {
    //     fmt::print("{}-{}\n", r.start, r.end);
    // }
    //
    // fmt::print("----------\n");
    std::vector<range> ranges{};
    for (usize i = 0; i < range_vec.size(); i += 1) {
        auto const& r = range_vec[i];
        if (ranges.empty()) {
            ranges.push_back(r);
            continue;
        }
        if (ranges.back().start <= r.start && ranges.back().end >= r.end) {
            continue;
        }
        if (ranges.back().end >= r.start) {
            ranges.back().end = r.end;
            continue;
        }
        ranges.push_back(r);
    }
    fmt::print("\n");
    f64 sum = 0.0;
    for (auto const& r : ranges) {
        // fmt::print("{}-{}  ", r.start, r.end);
        auto const d = (r.end - r.start) + 1;
        fmt::print("{}\n", d);
        sum += d;
    }
    fmt::print("res: {}\n", sum);
    //
    // std::vector<f64> ranges{};
    // for (auto const& value : set) ranges.push_back(value);
    // set = {};
    // std::ranges::sort(ranges);
    //
    //
    // // for (auto const& id : valid_ids) {
    // //     fmt::print("{} ", id);
    // // }
    // fmt::print("\n");
    //
    // fmt::print("res: {}\n", sum);
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day06.cpp
+++ b/2025/day06.cpp
@@ -0,0 +1,130 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(123 328  51 64 
 45 64  387 23 
  6 98  215 314
 *   +   *   +  )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    // str = aoc::trim(str);
    // fmt::print("INPUT\n");
    // fmt::print("⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼⎽⎼⎻⎺⎻⎼\n");
    // fmt::print("{}\n", str);
    // fmt::print("{}\n", std::string(80, '-'));
    auto vec = str | std::views::split("\r\n"sv) | std::views::transform([](auto&& line) {
            return line | std::views::split(" "sv)
                        | std::views::filter([](auto&& tok) { return !std::ranges::empty(tok); })
                        | std::views::transform([](auto&& tok) {
                            return aoc::trim(std::string{std::begin(tok), std::end(tok)});
                          })
                        | std::ranges::to<std::vector>();
      }) | std::ranges::to<std::vector>();
    std::vector<std::vector<std::string>> nums{};
    std::vector<std::string> ops{};
    for (usize i = 0; i < vec.size(); ++i) {
        for (usize j = 0; j < vec[i].size(); ++j) {
            auto const& value = vec[i][j];
            if (nums.size() <= j) nums.push_back({});
            if (value == "*" || value == "+") {
                ops.push_back(value);
                continue;
            }
            nums[j].push_back(vec[i][j]);
        }
    }
    // fmt::print("{} {}\n", nums.size(), ops.size());
    f64 sum = 0.0;
    for (usize i = 0; i < nums.size(); ++i) {
        auto const& op = ops[i];
        f64 row_sum = op == "*" ? 1.0 : 0.0;
        for (usize j = 0; j < nums[i].size(); ++j) {
            if (op == "*") row_sum *= std::stod(nums[i][j]);
            else if (op == "+") row_sum += std::stod(nums[i][j]);
        }
        // fmt::print("sum: {}\n", row_sum);
        sum += row_sum;
    }
    auto lines = str | std::views::split("\r\n"sv) | std::views::transform([](auto&& line) {
                        return std::string{std::begin(line), std::end(line)};
                    }) | std::ranges::to<std::vector>();
    // for (usize i = 0; i < lines.size(); ++i) {
    //     fmt::print("| {} |\n", lines[i]);
    // }
    for (usize i = 0; i < lines.size(); ++i) {
        fmt::print("size: {}\n", lines[i].size());
    }
    std::vector<std::vector<std::string>> mat{};
    auto const w = lines[0].size();
    fmt::print("w: {}\n", w);
    for (isize j = w - 1; j >= 0; --j) {
        std::string tmp{};
        if (mat.empty()) mat.push_back({});
        for (usize i = 0; i < lines.size() - 1; ++i) {
            tmp += lines[i][j];
        }
        mat.back().push_back(aoc::trim(tmp));
        auto const ch = lines[lines.size() - 2][j];
        if (ch == '+' || ch == '*') {
            mat.push_back({});
            continue;
        }
    }
    f64 new_sum = 0.0;
    for (usize i = 0; i < mat.size() - 1; ++i) {
        auto const& op = ops[mat.size() - 2 - i];
        f64 row_sum = op == "*" ? 1.0 : 0.0;
        for (usize j = 0; j < mat[i].size(); ++j) {
            if (mat[i][j].empty()) continue;
            fmt::print("{},", aoc::trim(mat[i][j]));
            if (op == "*") row_sum *= std::stod(aoc::trim(mat[i][j]));
            else if (op == "+") row_sum += std::stod(aoc::trim(mat[i][j]));
        }
        new_sum += row_sum;
        fmt::print("\n");
    }
    fmt::print("res: {}, {}\n", sum, new_sum);
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day07.cpp
+++ b/2025/day07.cpp
@@ -0,0 +1,108 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include <tuple>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 .......S.......
 ...............
 .......^.......
 ...............
 ......^.^......
 ...............
 .....^.^.^.....
 ...............
 ....^.^...^....
 ...............
 ...^.^...^.^...
 ...............
 ..^...^.....^..
 ...............
 .^.^.^.^.^...^.
 ...............
 )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);
    auto mat = str | std::views::split("\n"sv) | std::views::transform([](auto line) {
                    return line | std::views::split(""sv)
                                | std::views::transform([](auto tok) {
                                        return std::string{std::begin(tok), std::end(tok)};
                                    })
                                | std::ranges::to<std::vector>();
      }) | std::ranges::to<std::vector>();
    struct beam {
        usize row;
        usize col;
    };
    std::vector<beam> beams{};
    for (usize i = 0; i < mat.size(); ++i) {
        for (usize j = 0; j < mat[i].size(); ++j) {
            if (mat[i][j] == "S") {
                beams.push_back({i, j});
                break;
            }
            auto const size = beams.size();
            for (usize k = 0; k < size; ++k) {
                if (beams[k].row == i - 1 && beams[k].col == j) {
                    if (mat[i][j] == ".") {
                        mat[i][j] = "|";
                        beams[k] = {i, j};
                    } else if (mat[i][j] == "^") {
                        beams[k] = {i, j - 1};
                        beams.push_back({i, j + 1});
                        mat[i][j - 1] = "|";
                        mat[i][j + 1] = "|";
                    }
                }
            }
        }
    }
    f64 sum = 0.0;
    for (usize i = 0; i < mat.size(); ++i) {
        for (usize j = 0; j < mat[i].size(); ++j) {
            if (mat[i][j] == "^") {
                if (mat[i - 1][j] == "|") sum += 1;
            }
        }
    }
    fmt::print("res: {}\n", sum);
    // for (auto const& row : mat) {
    //     for (auto const& col : row) {
    //         fmt::print("{}", col);
    //     }
    //     fmt::print("\n");
    // }
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day08.cpp
+++ b/2025/day08.cpp
@@ -0,0 +1,112 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include <tuple>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 162,817,812
 57,618,57
 906,360,560
 592,479,940
 352,342,300
 466,668,158
 542,29,236
 431,825,988
 739,650,466
 52,470,668
 216,146,977
 819,987,18
 117,168,530
 805,96,715
 346,949,466
 970,615,88
 941,993,340
 862,61,35
 984,92,344
 425,690,689
 )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);
    auto mat = str | std::views::split("\n"sv) | std::views::transform([](auto line) {
                    return line | std::views::split(""sv)
                                | std::views::transform([](auto tok) {
                                        return std::string{std::begin(tok), std::end(tok)};
                                    })
                                | std::ranges::to<std::vector>();
      }) | std::ranges::to<std::vector>();
    struct beam {
        usize row;
        usize col;
    };
    std::vector<beam> beams{};
    for (usize i = 0; i < mat.size(); ++i) {
        for (usize j = 0; j < mat[i].size(); ++j) {
            if (mat[i][j] == "S") {
                beams.push_back({i, j});
                break;
            }
            auto const size = beams.size();
            for (usize k = 0; k < size; ++k) {
                if (beams[k].row == i - 1 && beams[k].col == j) {
                    if (mat[i][j] == ".") {
                        mat[i][j] = "|";
                        beams[k] = {i, j};
                    } else if (mat[i][j] == "^") {
                        beams[k] = {i, j - 1};
                        beams.push_back({i, j + 1});
                        mat[i][j - 1] = "|";
                        mat[i][j + 1] = "|";
                    }
                }
            }
        }
    }
    f64 sum = 0.0;
    for (usize i = 0; i < mat.size(); ++i) {
        for (usize j = 0; j < mat[i].size(); ++j) {
            if (mat[i][j] == "^") {
                if (mat[i - 1][j] == "|") sum += 1;
            }
        }
    }
    fmt::print("res: {}\n", sum);
    // for (auto const& row : mat) {
    //     for (auto const& col : row) {
    //         fmt::print("{}", col);
    //     }
    //     fmt::print("\n");
    // }
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/2025/day09.cpp
+++ b/2025/day09.cpp
@@ -0,0 +1,112 @@
 #include <span>
 #include <algorithm>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <utility>
 #include <vector>
 #include <tuple>
 #include "fmt/std.h"
 #include "aoc/types.hpp"
 #include "aoc/utils.hpp"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 // starts at 50
 [[maybe_unused]]constexpr auto raw_str = R"(
 162,817,812
 57,618,57
 906,360,560
 592,479,940
 352,342,300
 466,668,158
 542,29,236
 431,825,988
 739,650,466
 52,470,668
 216,146,977
 819,987,18
 117,168,530
 805,96,715
 346,949,466
 970,615,88
 941,993,340
 862,61,35
 984,92,344
 425,690,689
 )";
 static auto entry([[maybe_unused]]std::span<char const*> const& args) -> void {
    // std::string str{raw_str};
    auto str = aoc::read_text("./input.txt").value_or("");
    str = aoc::trim(str);
    auto mat = str | std::views::split("\n"sv) | std::views::transform([](auto line) {
                    return line | std::views::split(""sv)
                                | std::views::transform([](auto tok) {
                                        return std::string{std::begin(tok), std::end(tok)};
                                    })
                                | std::ranges::to<std::vector>();
      }) | std::ranges::to<std::vector>();
    struct beam {
        usize row;
        usize col;
    };
    std::vector<beam> beams{};
    for (usize i = 0; i < mat.size(); ++i) {
        for (usize j = 0; j < mat[i].size(); ++j) {
            if (mat[i][j] == "S") {
                beams.push_back({i, j});
                break;
            }
            auto const size = beams.size();
            for (usize k = 0; k < size; ++k) {
                if (beams[k].row == i - 1 && beams[k].col == j) {
                    if (mat[i][j] == ".") {
                        mat[i][j] = "|";
                        beams[k] = {i, j};
                    } else if (mat[i][j] == "^") {
                        beams[k] = {i, j - 1};
                        beams.push_back({i, j + 1});
                        mat[i][j - 1] = "|";
                        mat[i][j + 1] = "|";
                    }
                }
            }
        }
    }
    f64 sum = 0.0;
    for (usize i = 0; i < mat.size(); ++i) {
        for (usize j = 0; j < mat[i].size(); ++j) {
            if (mat[i][j] == "^") {
                if (mat[i - 1][j] == "|") sum += 1;
            }
        }
    }
    fmt::print("res: {}\n", sum);
    // for (auto const& row : mat) {
    //     for (auto const& col : row) {
    //         fmt::print("{}", col);
    //     }
    //     fmt::print("\n");
    // }
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    try {
        entry({argv, std::next(argv, argc)});
    } catch (std::exception const& e) {
        fmt::print(stderr, "{}\n", e.what());
        return 1;
    }
    return 0;
 }
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,138 +3,17 @@ project(aoc VERSION 0.0.0)
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)  # Group CMake targets inside a folder
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)         # Generate compile_commands.json for language servers
-include(FetchContent)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-FetchContent_Declare(
+include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/platform.cmake")
    fmt
    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
    GIT_TAG        10.1.0
 )
 list(APPEND FETCH_CONTENTS fmt)
 FetchContent_Declare(
    utf8cpp
    GIT_REPOSITORY https://github.com/nemtrif/utfcpp.git
    GIT_TAG        v4.0.5
 )
 list(APPEND FETCH_CONTENTS utf8cpp)
 FetchContent_Declare(
    stb
    GIT_REPOSITORY https://github.com/mononerv/stb.git
    GIT_TAG        698c6fb9889c71494b49c9187d249af5fc87b211
 )
 list(APPEND FETCH_CONTENTS stb)
 # Turn off BUILD_TESTING globally to prevent CTest from being included in CTRE
 set(BUILD_TESTING OFF CACHE BOOL "Disable testing globally" FORCE)
 # Set the CTRE_BUILD_TESTS option before including the CTRE library
 set(CTRE_BUILD_TESTS OFF CACHE BOOL "Build ctre Tests" FORCE)
 FetchContent_Declare(
    ctre
    GIT_REPOSITORY https://github.com/hanickadot/compile-time-regular-expressions.git
    GIT_TAG        v3.9.0
 )
 list(APPEND FETCH_CONTENTS ctre)
-FetchContent_MakeAvailable(${FETCH_CONTENTS})
+add_subdirectory("2025")
 find_package(Threads REQUIRED)
-# Group dependencies in Visual Studio and Xcode
+# set(HEADERS "")
-if (CMAKE_GENERATOR MATCHES "Visual Studio" OR CMAKE_GENERATOR MATCHES "Xcode")
+# set(SOURCES "aoc.cpp")
-    set_target_properties(fmt PROPERTIES FOLDER deps)
+# add_executable(aoc ${HEADERS} ${SOURCES})
-    set_target_properties(stb PROPERTIES FOLDER deps)
+# target_include_directories(aoc PUBLIC ${PROJECT_SOURCE_DIR})
-endif()
+# target_compile_features(aoc PRIVATE cxx_std_23)
-
+# target_link_libraries(aoc PRIVATE ${PLATFORM_LINK_LIBRARIES})
-set(BASE_DEFINITIONS "ASIO_STANDALONE")
+# target_compile_definitions(aoc PRIVATE ${PLATFORM_DEFINITIONS})
-if (APPLE)
+# target_compile_options(aoc PRIVATE ${BASE_OPTIONS})
-    message("Platform Apple")
+# source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${HEADERS} ${SOURCES})
    list(APPEND BASE_DEFINITIONS
        "AOC_PLATFORM=Apple"
    )
    set(IS_UNIX true)
 elseif (UNIX AND NOT APPLE AND NOT EMSCRIPTEN)  # Linux, BSD, Solaris, Minix
    message("Platform Unix")
    list(APPEND BASE_DEFINITIONS
        "AOC_PLATFORM=Linux"
    )
    set(IS_UNIX true)
 elseif (WIN32)
    message("Platform Windows")
    list(APPEND BASE_DEFINITIONS
        "AOC_PLATFORM=Windows"
    )
 else()
    message(FATAL_ERROR "Unkown platform!")
 endif()
 # Compiler specific options
 if (NOT MSVC)
    set(BASE_OPTIONS
        "-Wall"
        "-Wextra"
        "-Wconversion"
        "-Wpedantic"
        "-Wshadow"
        "-Werror"
        # fmt warnings
        "-Wno-unknown-attributes"
        # ctre warning
        "-Wno-missing-template-arg-list-after-template-kw"
    )
 else()
    set(BASE_OPTIONS
        "/W4"
        "/WX"
        "/utf-8"
        "/Zc:__cplusplus"
        #"/fsanitize=address"  # Doesn't work without Visual Studio
    )
 endif()
 set(HEADERS
    aoc/utils.hpp
 )
 set(SOURCES "")
 add_library(aoclib OBJECT ${HEADERS} ${SOURCES})
 target_include_directories(aoclib
    PUBLIC
    ${PROJECT_SOURCE_DIR}
    PRIVATE
    ${PROJECT_SOURCE_DIR}/aoc
 )
 target_compile_features(aoclib PRIVATE cxx_std_23)
 target_compile_options(aoclib PRIVATE ${BASE_OPTIONS})
 target_compile_definitions(aoclib
    PRIVATE
    ${BASE_DEFINITIONS}
 )
 target_link_libraries(aoclib
    PUBLIC
    fmt
    utf8cpp
    ctre
    stb::stb
    Threads::Threads
 )
 source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${HEADERS} ${SOURCES})
 add_subdirectory(sol/24)
 set(HEADERS "")
 set(SOURCES "aoc.cpp")
 add_executable(aoc ${HEADERS} ${SOURCES})
 target_include_directories(aoc
    PUBLIC
    ${PROJECT_SOURCE_DIR}
    PRIVATE
    ${PROJECT_SOURCE_DIR}/aoc
 )
 target_compile_features(aoc PRIVATE cxx_std_23)
 target_compile_options(aoc PRIVATE ${BASE_OPTIONS})
 target_compile_definitions(aoc
    PRIVATE
    ${BASE_DEFINITIONS}
 )
 target_link_libraries(aoc
    PUBLIC
    aoclib
    aoc24
 )
 source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${HEADERS} ${SOURCES})
--- a/README.md
+++ b/README.md
@@ -14,12 +14,6 @@ This project has support for different languages.
 There are different ways to setup this project, using `ninja` or Visual Studio.
 To use `miniaudio` to play audio on host machine use the flag `-DUSE_MINIAUDIO=ON`.
 ```sh
 cmake -S . -Bbuild -GNinja -DCMAKE_BUILD_TYPE=Debug
 ```
 Use `ninja` to build.
--- a/aoc.cpp
+++ b/aoc.cpp
@@ -1,25 +0,0 @@
 #include <span>
 #include <vector>
 #include <fstream>
 #include <expected>
 #include <system_error>
 #include <ranges>
 #include <string>
 #include <algorithm>
 #include <numeric>
 #include "fmt/format.h"
 #include "aoc/utils.hpp"
 #include "sol/24/aoc.hpp"
 auto entry([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    return aoc24::entry(args);
 }
 auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int {
    auto const res = entry({argv, static_cast<std::size_t>(argc)});
    if (res) return 0;
    fmt::print(stderr, "{}: {}\n", res.error().err.message(), res.error().msg);
    return 1;
 }
--- a/aoc/types.hpp
+++ b/aoc/types.hpp
@@ -0,0 +1,41 @@
 #ifndef AOC_TYPES_HPP
 #define AOC_TYPES_HPP
 #include <type_traits>
 #include <cstddef>
 #include <limits>
 #include <numbers>
 #include <memory>
 #include <system_error>
 #include <expected>
 #include <fstream>
 #include <ranges>
 #include <vector>
 namespace aoc {
 namespace types {
 using f32 = float;
 using f64 = double;
 using u8  = std::uint8_t;
 using u16 = std::uint16_t;
 using u32 = std::uint32_t;
 using u64 = std::uint64_t;
 using usize = std::size_t;
 using isize = std::ptrdiff_t;
 using i8  = std::int8_t;
 using i16 = std::int16_t;
 using i32 = std::int32_t;
 using i64 = std::int64_t;
 using c8  = char;
 using c16 = char16_t;
 using c32 = char32_t;
 }
 using namespace aoc::types;
 }
 #endif  // !AOC_TYPES_HPP
--- a/aoc/utils.hpp
+++ b/aoc/utils.hpp
@@ -1,5 +1,5 @@
-#ifndef AOC_AOC_HPP
+#ifndef AOC_UTILS_HPP
-#define AOC_AOC_HPP
+#define AOC_UTILS_HPP
 #include <type_traits>
 #include <cstddef>
@@ -11,42 +11,11 @@
 #include <fstream>
 #include <ranges>
 #include <vector>
 #include <string>
 #include "aoc/types.hpp"
 namespace aoc {
 namespace types {
 using f32 = float;
 using f64 = double;
 using b8  = bool;
 using u8  = std::uint8_t;
 using u16 = std::uint16_t;
 using u32 = std::uint32_t;
 using u64 = std::uint64_t;
 using i8  = std::int8_t;
 using i16 = std::int16_t;
 using i32 = std::int32_t;
 using i64 = std::int64_t;
 using c8  = char;
 }
 using f32 = types::f32;
 using f64 = types::f64;
 using b8  = types::b8;
 using u8  = types::u8;
 using u16 = types::u16;
 using u32 = types::u32;
 using u64 = types::u64;
 using i8  = types::i8;
 using i16 = types::i16;
 using i32 = types::i32;
 using i64 = types::i64;
 using c8  = types::c8;
 template <typename T>
 concept Integral = std::is_integral<T>::value;
@@ -84,6 +53,55 @@ inline auto read_text(std::string const& path) -> std::expected<std::string, aoc
 // ranges and view aliases
 template <typename T>
 using vec = std::vector<T>;
 inline constexpr auto split = std::views::split;
 [[maybe_unused]]constexpr auto map_to_str = std::views::transform([](auto const& str) {
    return std::string(std::begin(str), std::end(str));
 });
 [[maybe_unused]]constexpr auto map_to_sv = std::views::transform([](auto const& str) {
    return std::string_view(std::begin(str), std::end(str));
 });
 [[maybe_unused]]constexpr auto filter_non_empty = std::views::filter([](auto const& str) {
    return !str.empty();
 });
 template <class F>
 struct pipe {
    F f;
 };
 template <class F>
 pipe(F) -> pipe<F>;
 template <class F>
 auto operator|(std::string s, pipe<F> p) -> decltype(auto) {
    return p.f(std::move(s));
 }
-#endif  // !AOC_AOC_HPP
+inline auto ltrim(std::string s) -> std::string {
    s.erase(
        std::begin(s),
        std::find_if(s.begin(), s.end(), [](char ch) {
            return !std::isspace(static_cast<char>(ch));
        }));
    return s;
 }
 inline auto rtrim(std::string s) -> std::string {
    s.erase(
        std::find_if(s.rbegin(), s.rend(), [](char ch) {
            return !std::isspace(static_cast<char>(ch));
        }).base(),
        s.end());
    return s;
 }
 inline auto trim(std::string s) -> std::string {
    return ltrim(rtrim(std::move(s)));
 }
 }
 #endif  // !AOC_UTILS_HPP
--- a/cmake/Findctre.cmake
+++ b/cmake/Findctre.cmake
@@ -0,0 +1,74 @@
 if (DEFINED _FINDCTRE_INCLUDED)
    unset(ctre_FOUND CACHE)
    unset(ctre_DIR CACHE)
    unset(ctre_INCLUDE_DIR CACHE)
    unset(ctre_LIBRARIES CACHE)
    unset(ctre_VERSION CACHE)
    return()
 endif()
 set(_FINDCTRE_INCLUDED TRUE)
 find_package(ctre QUIET)
 if (NOT ctre_FOUND)
    message(STATUS "ctre not found. Fetching via FetchContent...")
    include(FetchContent)
    find_program(GIT_EXECUTABLE git)
    if (GIT_EXECUTABLE)
        set(CTRE_FETCH_METHOD "GIT")
    else()
        set(CTRE_FETCH_METHOD "ZIP")
    endif()
    if (CTRE_FETCH_METHOD STREQUAL "GIT")
        FetchContent_Declare(
            ctre
            GIT_REPOSITORY https://github.com/hanickadot/compile-time-regular-expressions.git
            GIT_TAG        v3.10.0
        )
    else()
        FetchContent_Declare(
            ctre
            URL https://github.com/hanickadot/compile-time-regular-expressions/archive/refs/tags/v3.10.0.zip
        )
    endif()
    # Turn off BUILD_TESTING globally to prevent CTest from being included in CTRE
    set(BUILD_TESTING OFF CACHE BOOL "Disable testing globally" FORCE)
    # Set the CTRE_BUILD_TESTS option before including the CTRE library
    set(CTRE_BUILD_TESTS OFF CACHE BOOL "Build ctre Tests" FORCE)
    FetchContent_MakeAvailable(ctre)
 else()
    message(STATUS "ctre found.")
    # Ensure we have a usable target
    if (NOT TARGET ctre::ctre)
        if (TARGET ctre)
            add_library(ctre::ctre ALIAS ctre)
        else()
            message(FATAL_ERROR "ctre was found, but no CMake target 'ctre' or 'ctre::ctre' exists.")
        endif()
    endif()
    # Populate the standard variables
    set(ctre_FOUND TRUE)
    set(ctre_LIBRARIES ctre::ctre)
    get_target_property(_ctre_inc ctre::ctre INTERFACE_INCLUDE_DIRECTORIES)
    set(ctre_INCLUDE_DIR "${_ctre_inc}")
 endif()
 if (NOT TARGET ctre::ctre)
    if (TARGET ctre)
        add_library(ctre::ctre ALIAS ctre)
    else()
        message(FATAL_ERROR "Could not find or fetch ctre; no target ctre or ctre::ctre available")
    endif()
 endif()
 set(ctre_FOUND        TRUE)
 set(ctre_LIBRARIES    ctre::ctre)
 set(ctre_VERSION      "${ctre_VERSION}")         # this comes from the ctre project
 get_target_property(_ctre_inc ctre::ctre INTERFACE_INCLUDE_DIRECTORIES)
 set(ctre_INCLUDE_DIR  "${_ctre_inc}")
--- a/cmake/Findfmt.cmake
+++ b/cmake/Findfmt.cmake
@@ -0,0 +1,70 @@
 if (DEFINED _FINDFMT_INCLUDED)
    unset(fmt_FOUND CACHE)
    unset(fmt_DIR CACHE)
    unset(fmt_INCLUDE_DIR CACHE)
    unset(fmt_LIBRARIES CACHE)
    unset(fmt_VERSION CACHE)
    return()
 endif()
 set(_FINDFMT_INCLUDED TRUE)
 find_package(fmt QUIET)
 if (NOT fmt_FOUND)
    message(STATUS "fmt not found. Fetching via FetchContent...")
    include(FetchContent)
    find_program(GIT_EXECUTABLE git)
    if (GIT_EXECUTABLE)
        set(FMT_FETCH_METHOD "GIT")
    else()
        set(FMT_FETCH_METHOD "ZIP")
    endif()
    if (FMT_FETCH_METHOD STREQUAL "GIT")
        FetchContent_Declare(
            fmt
            GIT_REPOSITORY https://github.com/fmtlib/fmt.git
            GIT_TAG        12.0.0
        )
    else()
        FetchContent_Declare(
            fmt
            URL https://github.com/fmtlib/fmt/releases/download/12.0.0/fmt-12.0.0.zip
        )
    endif()
    FetchContent_MakeAvailable(fmt)
 else()
    message(STATUS "fmt found.")
    # Ensure we have a usable target
    if (NOT TARGET fmt::fmt)
        if (TARGET fmt)
            add_library(fmt::fmt ALIAS fmt)
        else()
            message(FATAL_ERROR "fmt was found, but no CMake target 'fmt' or 'fmt::fmt' exists.")
        endif()
    endif()
    # Populate the standard variables
    set(fmt_FOUND TRUE)
    set(fmt_LIBRARIES fmt::fmt)
    get_target_property(_fmt_inc fmt::fmt INTERFACE_INCLUDE_DIRECTORIES)
    set(fmt_INCLUDE_DIR "${_fmt_inc}")
 endif()
 if (NOT TARGET fmt::fmt)
    if (TARGET fmt)
        add_library(fmt::fmt ALIAS fmt)
    else()
        message(FATAL_ERROR "Could not find or fetch fmt; no target fmt or fmt::fmt available")
    endif()
 endif()
 set(fmt_FOUND        TRUE)
 set(fmt_LIBRARIES    fmt::fmt)
 set(fmt_VERSION      "${fmt_VERSION}")         # this comes from the fmt project
 get_target_property(_fmt_inc fmt::fmt INTERFACE_INCLUDE_DIRECTORIES)
 set(fmt_INCLUDE_DIR  "${_fmt_inc}")
--- a/cmake/Findutf8cpp.cmake
+++ b/cmake/Findutf8cpp.cmake
@@ -0,0 +1,70 @@
 if (DEFINED _FINDUTF8CPP_INCLUDED)
    unset(utf8cpp_FOUND CACHE)
    unset(utf8cpp_DIR CACHE)
    unset(utf8cpp_INCLUDE_DIR CACHE)
    unset(utf8cpp_LIBRARIES CACHE)
    unset(utf8cpp_VERSION CACHE)
    return()
 endif()
 set(_FINDUTF8CPP_INCLUDED TRUE)
 find_package(utf8cpp QUIET)
 if (NOT utf8cpp_FOUND)
    message(STATUS "utf8cpp not found. Fetching via FetchContent...")
    include(FetchContent)
    find_program(GIT_EXECUTABLE git)
    if (GIT_EXECUTABLE)
        set(UTF8CPP_FETCH_METHOD "GIT")
    else()
        set(UTF8CPP_FETCH_METHOD "ZIP")
    endif()
    if (UTF8CPP_FETCH_METHOD STREQUAL "GIT")
        FetchContent_Declare(
            utf8cpp
            GIT_REPOSITORY https://github.com/nemtrif/utfcpp.git
            GIT_TAG        v4.0.6
        )
    else()
        FetchContent_Declare(
            utf8cpp
            URL https://github.com/nemtrif/utfcpp/archive/refs/tags/v4.0.6.zip
        )
    endif()
    FetchContent_MakeAvailable(utf8cpp)
 else()
    message(STATUS "utf8cpp found.")
    # Ensure we have a usable target
    if (NOT TARGET utf8cpp::utf8cpp)
        if (TARGET utf8cpp)
            add_library(utf8cpp::utf8cpp ALIAS utf8cpp)
        else()
            message(FATAL_ERROR "utf8cpp was found, but no CMake target 'utf8cpp' or 'utf8cpp::utf8cpp' exists.")
        endif()
    endif()
    # Populate the standard variables
    set(utf8cpp_FOUND TRUE)
    set(utf8cpp_LIBRARIES utf8cpp::utf8cpp)
    get_target_property(_utf8cpp_inc utf8cpp::utf8cpp INTERFACE_INCLUDE_DIRECTORIES)
    set(utf8cpp_INCLUDE_DIR "${_utf8cpp_inc}")
 endif()
 if (NOT TARGET utf8cpp::utf8cpp)
    if (TARGET utf8cpp)
        add_library(utf8cpp::utf8cpp ALIAS utf8cpp)
    else()
        message(FATAL_ERROR "Could not find or fetch utf8cpp; no target utf8cpp or utf8cpp::utf8cpp available")
    endif()
 endif()
 set(utf8cpp_FOUND        TRUE)
 set(utf8cpp_LIBRARIES    utf8cpp::utf8cpp)
 set(utf8cpp_VERSION      "${utf8cpp_VERSION}")         # this comes from the utf8cpp project
 get_target_property(_utf8cpp_inc utf8cpp::utf8cpp INTERFACE_INCLUDE_DIRECTORIES)
 set(utf8cpp_INCLUDE_DIR  "${_utf8cpp_inc}")
--- a/cmake/platform.cmake
+++ b/cmake/platform.cmake
@@ -0,0 +1,98 @@
 # cmake/platform.cmake
 # Platform detection + compiler options
 if(DEFINED PLATFORM_CONFIG_INCLUDED)
    return()
 endif()
 set(PLATFORM_CONFIG_INCLUDED TRUE)
 # -------------------------------------------------------
 # Platform detection
 # -------------------------------------------------------
 if(APPLE)
    set(PLATFORM "macOS")
    message(STATUS "Platform: ${PLATFORM}")
    set(PLATFORM_LINK_LIBRARIES
        "-framework Cocoa"
        "-framework IOKit"
        "-framework CoreVideo"
        "-framework OpenGL"
    )
 elseif(UNIX AND NOT APPLE AND NOT EMSCRIPTEN) # Linux, BSD, etc.
    set(PLATFORM "Linux")
    message(STATUS "Platform: ${PLATFORM}")
    set(PLATFORM_LINK_LIBRARIES
        dl
        m
        GL
        X11
    )
 elseif(WIN32)
    set(PLATFORM "Windows")
    message(STATUS "Platform: ${PLATFORM}")
    set(PLATFORM_LINK_LIBRARIES
        OpenGL32.lib
    )
    set(PLATFORM_DEFINITIONS
        ${PLATFORM_DEFINITIONS}
        "_WIN32_WINNT=0x0A00"
    )
 elseif(EMSCRIPTEN)
    set(PLATFORM "Emscripten")
    message(STATUS "Platform: ${PLATFORM}")
    # Emscripten specific flags (not the warnings; those are below)
    add_compile_options(
        -pthread
        -fexceptions
        -sUSE_PTHREADS=1
    )
    add_link_options(
        -pthread
        -fexceptions
        -sUSE_PTHREADS=1
    )
 else()
    message(FATAL_ERROR "Platform: Unknown!")
 endif()
 # -------------------------------------------------------
 # Compiler specific options (BASE_OPTIONS)
 # -------------------------------------------------------
 if(NOT MSVC)
    set(BASE_OPTIONS
        -Wall
        -Wextra
        # -Werror
        # fmt warnings
        -Wno-deprecated-literal-operator
    )
    if(EMSCRIPTEN)
        list(APPEND BASE_OPTIONS
            # asio
            -Wno-sign-conversion
            -Wno-shadow
            -Wno-shorten-64-to-32
            -Wno-implicit-int-conversion
            -Wno-unused-private-field
            -Wno-deprecated-declarations
        )
    endif()
 else()
    set(BASE_OPTIONS
        /W4
        # /WX          # warnings as errors (MSVC equivalent of -Werror)
        /utf-8
        /Zc:__cplusplus
        #/fsanitize=address  # Doesn't work without Visual Studio
    )
 endif()
--- a/dat/24/ex/01.txt
+++ b/dat/24/ex/01.txt
@@ -1,6 +0,0 @@
 3   4
 4   3
 2   5
 1   3
 3   9
 3   3
--- a/dat/24/ex/02.txt
+++ b/dat/24/ex/02.txt
@@ -1,6 +0,0 @@
 7 6 4 2 1
 1 2 7 8 9
 9 7 6 2 1
 1 3 2 4 5
 8 6 4 4 1
 1 3 6 7 9
--- a/dat/24/ex/03.txt
+++ b/dat/24/ex/03.txt
@@ -1 +0,0 @@
 xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))
--- a/dat/24/ex/03b.txt
+++ b/dat/24/ex/03b.txt
@@ -1 +0,0 @@
 xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))
--- a/dat/24/ex/04.txt
+++ b/dat/24/ex/04.txt
@@ -1,10 +0,0 @@
 MMMSXXMASM
 MSAMXMSMSA
 AMXSXMAAMM
 MSAMASMSMX
 XMASAMXAMM
 XXAMMXXAMA
 SMSMSASXSS
 SAXAMASAAA
 MAMMMXMMMM
 MXMXAXMASX
--- a/dat/24/ex/05.txt
+++ b/dat/24/ex/05.txt
@@ -1,28 +0,0 @@
 47|53
 97|13
 97|61
 97|47
 75|29
 61|13
 75|53
 29|13
 97|29
 53|29
 61|53
 97|53
 61|29
 47|13
 75|47
 97|75
 47|61
 75|61
 47|29
 75|13
 53|13
 75,47,61,53,29
 97,61,53,29,13
 75,29,13
 75,97,47,61,53
 61,13,29
 97,13,75,29,47
--- a/dat/24/re/01.txt
+++ b/dat/24/re/01.txt
--- a/dat/24/re/02.txt
+++ b/dat/24/re/02.txt
--- a/dat/24/re/03.txt
+++ b/dat/24/re/03.txt
@@ -1,6 +0,0 @@
 '{}mul(339,896)>^+!)^mul(799,303)don't()>mul(188,763)'<};who()select()%;+mul(924,355)mul(492,757) what()mul(582,171)][*+select()#mul(840,899){!when()from()%<mul(711,51)when()why()} ~mul(131,623)&select()^how()mul(966,541)[*>where()mul(318,527)} :!-'mul(530,886)?}>mul(937,475) $;),%:}mul(201,723)where()select()mul(673,729)why()who()^'who()mul(673,694)[+mul(295,161)[!how(88,740)*mul(364,904)how()<]when()+where()mul(329,432)when()mul(499,11)who(238,444)<mul(533,879)'&who()#$;(&'<mul(65,49)#where(630,776)#mul(979,846)select()%]!<>)#~mul(775,866);,[)':where()%{[mul(835,890)+&&select()&[when()why(783,259) select()mul(735,871)!)when()'what()[/:mul(952,728)mul(633,505)@ -(?mul(176,469)*%what()>what()who()@{+do()'mul(117,634)-?(^^%:mul(234,514)where()@%mul(291,507)#from()*!*mul(668,282)@&)>,:select()>{%mul(195,300)-why()select()+&~>/^from()mul(801,834)why()</when()<&]mul(265,493)$what(382,576)#(+#']mul(590,771)%/mul(716,564)#}'mul(359,60)*~];#]mul(197,425)who()+^^?[:@[mul(752,102)]mul(271,88)mul(933,166)why()@,$^+?mul(343,220)+'what();mul(309,990){from(665,45)why(){ when(){ mul(782,953)+,:who()@]*mul(779,796)select()mul(616,478)&]>~mul(463,630){*, from()$}:@mul(280,83)when()[mul(358,910)[;'why()where()mul(242,569)from()#<>from()&mul(553,455)%who()<when()where()[mul(567,429)what()mul(257,307)}<don't()what()>)mul(284,63)%%*+?mul(437,226)* }how()when()~%'mul(57,491)]select(918,666)where()$when()why()'from()?]mul(321,301)'~:mul(619,356):mul(78,106)what()}!+~mul(609,442);  $where()$who()mul(996,918)mul(217,653)@##:#mul(998,408))~<#where()from()who()who()what()(mul(305,980)-~(:>where();when()#mul(721,412)how()'< { mul(143,735){:]why(){#),@mul(670,301)$when(),}why()]?why(839,544)mul(120,681){when()$[?@-)mul(805,510)>from()))when();?'#mul(104,633)%<$%}why()mul(555,387)@$+mul(850,237)!^where()<}from()select()from()<@mul(298,559)who():from()+what();mul(556,540)$%<&(%don't()$/':'*)(mul(976,624)!~*/%why()mul(790,645):~^from()[{+*!mul(153,86)+select(){#!from()how()$mul(980,956)>from()select()}<}@}?~mul(151,20)select()mul(703*(){+]who()what()mul(827,322)+](}mul(531,132what()where()+mul(933,2){&$how()%#;]don't())[]mul(845,519)how(),]when()^mul(518,563)#,++$#mul(500,591)(#/what()where()how()from()mul(243,908);mul(574,691)/who(),who()how()&mul#{where()when()]!@mul(534,43)}do(),}/from()when()~{&@mul(92%what()~}mul(496,669)^(!+ ^~mul(28,334)mul(621,688)]mul(627,561))mul(206,37)]~^&mul(288,740,<@mul(540,77)<&:who(594,229)&'*who(){mul(923,453)mul(733,228)where()how()mul(104,17)/!why()~what()*@}mul(500,830)#'(&%{select()*?mul(301,211)]>@@,mul(21,358) ?mul(285,542)how()from())mul(361,19)(who()%}select(){*mul(362,324)<[]'&when()'mul,why()mul(352,273)mul(742,91)>mul(624,723)) ;@+mul(14,149)(from()%%,(mul(547,492)~+mul(712?@@@&{{mul(972,531)
 ]&%where()~}who()[how()]mul(602,51)how()+&>,{>] #do()from()~{,*[-mul(862,742)how()why()]%mul(432,72)what(){:do()%@!}-mul(663/+,what()--(&?mul(384,302)'@(mul(649,348)+from()%mul(184,596)~+}~mul(719,53)mul(634,179){-:where()mul(684,320where()when(395,300){who()how()^/;where()mul(849,756)!mul(530,108)#*+}what()^(]select()mul(333,615)[why()%?]~$how()mul(314,366)}where()mul(222,364)<){*[mul(449,95){:who(844,554)<;why()$who() mul(831,201))$mul(408,650)who()what()}<[do()~how()select()!]'why()<when()mul(478,641)what()<mul>]how(289,983)* <+%&mul(836,460)%mul(339,868)why():from()from()%mul(91,296)!+^,*when()who()from()-$mul(6,37)when()when()mul(69,574)who(),from(),how()mul(431,678~+how()]mul(644,184)-(?why(571,97)])why()from()mul(516>select()mul(67,86)+~%^!~what();mul(526,440)!+>?<:&mul(81,534)&}'mul(64,25)[-;mul(828$<>*mul(157,667)@[ *who()mul(356,285)select()(~*do()how()';why()&^?mul(165,944)select()mul(980,979)<:!~%mul(15why()$ mul(109,665)&-!why()]<'&mul(887,673)]mul(906,700)#mul}@-where()/{{ -mul(935,960),)''[{mul(533,431)what())'@mul(63,509)@why(464,997)$]mul(164,971)select()~where()how()#>' when()>mul(301,62) +;'+what()}!->mul(722,492))!'mul(262,457):@when()-/mul(902,705)~#(mul(640,550)/*$$#select()where(905,349)!&&don't()when()mul(998,104)select()from()select()'when()mul(37,27)!where()$:do()}mul(160,45)mul(716,642~,{+&+!}[}mul(281,768)who()-?;);%mul(270,620) mul(793from()(![(! : who()mul(481,293)?mul(264,360)where(){from();(select()~!from()mul(748,940)[~]why()$[+how(709,453)mul(590&!+*why()]when()mul(182,631)(how()?(select():;&]{mul(83,366)%when()when()&mul(878,366)why()[:,]mul(77,997);%/$&%]mul(827,204)mul(919,654)>,where()%+mul(678,952)who()@select()}*(mul(344,894)where()mul(408,29)#*!{}*~where(906,182)mul(144,162)!&#select()how()&why()~*#don't()-()]~:how()mul(803,649)]@?#;mul(170,978)mul(263,974)!@why()$how()@mul(155,265)&/%^/mul(571,825)$where()mul(507,171)from()^(~*mul(437,680)from()who()>select()}mul(332,921) where()mul(218,74)})from()/mul(470,570)why()@?who()don't()@({*mul(931,767)mul(486,567):&])%/{]%mul(901,942),' ]why()^where()do(){#,what()mul(331,184)how()when()how()*{:^){mul(339,48){'(what(545,390)mul(818,891)who()mul(828,226), how()where()'#,%?mul(798,324))<how()mul(145,827)mul(256,218)who()?};when()/^mul(125,982)!%mul(274,98)}%what()-:who()},;mul(748,186)(()when()?where()why()<where()do()<%where()mul(556,171){>';mul(337,760)[#mul(350,889)~#how()mul(859,480){}^?&select()where()do()~<mul(808,237)$ % [#mul(218,295)mul(583,684);from():,from()+&-mul(628,340)[why()}why()?how()/,'mul(639,874)^}who()!why()mul(607,392)-&who()@+what()%mul(263,676)+%:]{ :-select()mul(166,500)/mul(711,477) : {how()<mul(939,832)'+<{!,when(),?)mul}[what()where()+:-,from()mul(457,751)&from()+why()mul(219,492)^/$! $from(832,913)@+!mul(892,437)+[>); who()^mul(640,455}why()#mul(744,51)'[who()/> select()mul^where()select()^}^mul(450,596))select()what()}&%;?mul(218,957)+*who(),}do()from()^} when()+[select(938,490))select()mul(406{how()(+who()()select()mul(329,937)&!mul(693,766)<{+}<[@mul)]%why()when()){~[ who()mul(888,144)~$:,mul(517,97)@) ~mul(394,320)why()when()who()(,%mul(761,855)
 mul(22,362)('from(886,421)]mul(730,655)[@,how()(mul(692,165)]&$when()!}from()%mul(481,375)where()~mul(954,570)?why()-+mul(338,656)who()~ <}from()mul(616,31)where()/]:select())?from()mul(113,2):?$mul(295,905)];mul(410,181)@%${^how()>select()where()-mul(779>+what();^who(),>)mul(599,200)%~][select()>+>mul(486,481)*!who(693,495)-$mul(237,686)? how()! -@#do()#<(where()-&'>&what()mul(321,434)}@what()~/from()do()?who()$where()mul(328,792)select()how()mul(82,296)#</ why()what()}mul(859,169)[>,who())/when(637,168)mul(465,709)mul(208,775)^[@when()>>##<>mul(379,29)%mul(826,43){when()?who()*why()do()&[):@mul(411,966)^mul(24,557)<;where()mul(391,794)#;mul(592,819)+,}'%'mul(210,928)%mul(29,613);$who()why()!]who()mul(56,646)*@]-{~+:mul(425,457)>mul(896,578)%(how()](*where()when()select(237,23)mul(895,482)~<{mul(432,547)who(471,124){mul(483,785)*mul(422,876)^>& ;(^where()~#mul(709,114)(:;where()select()?%mul(263,276)&?;from()&&~(mul(113,694)who()mul(228,70): >[:@ ;@mul(707,104);:mul(423,229)&$[]>who()mul(194,895)><&&when()%%mul(836,144)<^!~)/;#who()>mul(786,723)?!#[mul(287;why()mul(734,761)!who()/<)mul(520,746)where(){!>>select()how()mul(185,986)mul(566,786)why()when()[~do(),}mul(188,610)/+^%<why()mul(784,533);-;?#/when(743,88)mul(841,352)from()why()how()+/!<mul(728,38);<why()from()>-how()[mul(671,105)*[}[mul(403,996)mul(214+($?{when()mul(268,651),[>mul(660,864)%-/how()->([~mul(769,53)?from(197,675)^[-mul(83,519)where()select()don't()[:from()@{who() ?mul(305,335)[when()when();where(751,621)what()mul(395,86)how()?,who():>mul(349,362)how()?*select()when()from()who()where()''mul(414,725)*)when()select()]+mul(180,197)$who()why()&%'}mul(531who()#{mul(370,295)who()%mul(121,586)*^^%?>{,when()mul(944,189)&[/)select()>&^mul(222,28)@</<mul(752,302)}!<why()'$where()?,mul(974,242)}>!where()'mul(449,827)^[mul(289,78)$how(287,947)mul(337,811)why()''-what()[/when(370,472)from()>mul(865,636){#mul(524,198)why(714,875)!*%mul(181,23)^)why()?:what(630,704)+}mul(569,165);when()')where(597,70):$where()why(),mul(15,411)* ) &don't()mul(124,709)$;/[+select()(</mul(99,652)mul(53,14),select()where()mul(380,904)^}!?**[@when()mul(491,229)$#where()mul(245,344)select()select(){mul(297,527)'<from()/-,>{mul(50,277))*;+*<#do()!@mul~mul(19,630),,,*+{mul(404,379)mul(72,663)when()don't()where(221,302)from()^>mul(942,445)+^from()]from()*{)mul(83,601)-+what(): where()what()from(),mulwhy()where(856,731)&/+mul(777,574)!+when()<where()why()'>don't()*^<what()from();>mul(680,66)how()$mul(361,449):,how(766,248)#}&}[mul(869,603);;where()what()mul(385,816)[!' <-~from();mul(298,605*<mul(189,109)from()+/)!:mul(451,205)mul(949,138)from()+# $;}mul(356,99)who()*#-)':mul(95,448)who()$@who()-%&mul(167,343)mul(300*~%who()$(how();}])mul(919,379)>from()^mul(573,375)when()@(where()%mul(871,907)mul(718,918)?mul/~ ~what()-!select()~do()why():mul(682why()]mul(585,886)(,?+*?%!mul(684,834)what(786,470)mul(443,590))where(228,285) !/%?mul(815,879)#!/usr/bin/perl@mul(444,941)$select(687,764)%'(where()>-/mul(180,328)
 [/:@how()*what()!+mul(911,368)?/what()~(+]mul(843?$,who()mul(865,234)@]/-from()mul(397,906)^mul(806,349)]how()where()^)+%select()when()~mul(827,131)]don't()@+/mul(44,818)[,<,mul(295,441)what()/select()]^mul(756,90) [mul(67,416){mul(230,994)select()how()who()/mul(66,226);<~!when()mul(325,467),mul(6,370)mul(619,21)~<what(761,805)who())+?;^-mul(5,165{don't()how()who()#,mul(713,804) mul(737,356);mul(905,649who()what()mul(139,324)~from()mul(502,936)when()-&select()^']]who()mul(404}>mul(699,668))^<from()%!%>:mul(755,644)<%?#)mul(46,923!mul(730,880)]~]how()-why()'&mul(952,543)from()<what()what()where()>>!-mul(123,880){(<when()<mul(425,371)from(),how()+?]-*!where()mul(425,817)?!mul(668,3) who()mul(785,430)*mul(607,686)?] $~mul(979,796)]/@'why()mul(244,801)+when()how():mul(311,17)@:,#-why()($mul(486,732)mul(480,165)mul(153who():when()&~)who()$mul(662,582)<((what()* {/(&mul(894,455);;(how()what()[>mul(555,437)*mul(692,73)&*when()~>mul(465,602)(mul(471,204){%from();don't()$mul(945,735)from()select(520,626)>@who()]who()mul(615,73)):(;^^when(793,925)*&do(){mul(431,683)*+#select()where()from()?+mul(254,617)#%where()>;%don't()$who()#how()^[how()why()*mul(907where()select()(!:'!?@mul(208,995)}/:when()how(415,229)^-'from()mul;mul(22,79),']^?(mul(583,536):mul(355/-where()?<mul(281,314)how()^!+<;>~%,mul(990,358)//+&how() do()?who()%!}]mul(603,599)@mul(285,652){&@@mul(808,857when()when()%select()/'$@mul(585,541)from()@mul(136*#from()@mul(710,522) #*when()*}/mul(801,485) >/mul(393,477)where()(mul(13,599)what()when()(*%>@?];mul(808,562)>mul(407,85)mul(244/$&!+where()mul(67,663)<from()-{where()% where()mul(629,684){}#^)-why()where()+mul(79,607)*don't()'from(27,368)*where()<#^mul(697,649)/(why()~from()*mul(448,917)mul>-mul(934,570)]mul(857,473)who()mul(585,495)where()mul(45,904)!when()where())-:mul(747,283)why()#where();what()how(){'from()mul(405,574)[,?what()why()-([mul}where()select(450,140) /<mul(198,934)when(394,203)why()<']@,mul(299,635)>@who():<mul(629,260)&!/!who()mul(360,191)select()#*'mul(409,799)select()}} *from()*,mul(902,917)do()where()why()%}}]+mul(548,522)^]how()->@who(),>~mul(104,734)$]#-#who()mul(760,886)what()<where()[#mul(150,972)mul(276,427)from(729,212)where()% {!mul(534,660)when()-?mul(406,3),!%*why())mul(990,129)how() what()mul(532,895)how()when()mul(869,39))/;->&where(352,510)->(don't()mul(863,264)$<)where()*/(@'mul(756,795)^)]mul(278,155):&!%$select()mul(189,750)[$#-/mul(549,580))^how(152,70):$mul(28,530)-],;]mul(33,157);!/+?what(253,786)%what()mul(841,40)+&when()why()^mul(898,936)!])mul(891,523);>mul(312,16)@how()*where()'where()<@?mul(967,420)/}why()~,mul(581,636)/ [mul(673,139)who()>mul(578,980):,<what():}{&: mul(605}^-+~]'@$ }mul(229,41)#@)+mul:mul(447,836)how()*%*what():;['*mul(672,963);what()mul(287,244)%;+<%{@mul(448,425)//+~([who()mul(871,92)]}?++[--%*mul(42,503)#?[{$^}>%mul(75,107)+)how()-mul:/where()why()mul(315,687)!{%'what()mul(110,111)+ #:%!mul(731,760)
 (+&mul(887,468)$::)],mul(765,973)'from()from()*mul(810,344)?what()mul(768,468)~'+)select()where()(select()where()$mul(576,358)%??'mul(41,789how()when()&-mul(606,191)!when()'~mul]]how():;~{how()mul(15,34)>%%*^how(54,122)$@mul(739,223)how()~*@!don't()]:{~'@>why()<mul(929,311)(%@;mul(949,785)>-]&how() **;}mul(900,428)select()]$'mul(874,363)what()@mul(892,45)^*+mul(387,178)?<how()mul(383,479)/@#who()/)do()^}where(662,769)~$mul(845,224)$from()mul(60,887)mul(773,136)%^mul(436,490)%+mul(283,346);?mul(77,681)^##mul(556,520)$how()(&^how()select()) who()mul(418,701)!^:},where()/%mul(871,886)when()[mul(409,599)*from(463,269){from(324,295)from()who()mul(790,739)mul(677;why()}^when()how()+from()don't()&*%,why()#!how(252,857)-?mul(728,703)how()who() ')^from()'how()^do()[mul+!@;~select()select()mul(108,547)select()mul(96,190)];,{what()/when(742,998){})mul(632,699)how()'(what()when(),^mul(917,127)where()^()<mul(763,236)/^@+(when()^!%*mul(270,488))?what(116,413)!?:mul(922,831)$,who()@!*(>mul(823,845){where()mul(854,982);;/how()-why()mul(899,363)[where()who()what()>$]['do()<'how())mul(201,507)select(): >select()select()what()/where()*do()}@when(392,773)?mul(231,610){- why()*from()when():select():mul(334,751)from()how()~+who()-mul(811,647){^mul(116,805)^where()@}mul(691,631) when()&%from(),@^mul(336,461) ,what())who()when(540,382)'mul(549,430)%]from())@mul(339,808)?mul(264,497)'when()what()~who()~@how()$+mul(965,916)('who())%~from()from()%mul(776,506)/select()mul(385,184)*##select()mul(691,451)]$$mul(303,437);!when()&/<>]^mul(524,315)#^)mul(42,992who()}&-select()mul(902,182)(!''where()'+mul(48,755)@~what(644,7)$select()&%who()-mul(629,650)!^mul(822,985){/select()why()where()!who()%%mul(102,630)why()-{don't(),mul(166,527)'where()mul(245,921)select()-select()mul~>select()'%who()<+,mul(795,941))%$,what()where()>mul(414,585)from(26,999){mul(293,208)when()?#?<!who()mul(781,159)/#do()select()mul(409,682)/select():who()mul(565,948)mul(903,713):how()>mul(99,672)why()(select()+]when()mul(300,836)[<mul(129,851)mul(545,309)why(388,433)@~/mul@how())&*mul(466,194) };;@what()who()(mul(213,565what()why()how()#%,<where()mul(844,768))&()]}-<why()+don't()/};'</&mul(134,385)mul(176,788)[-]]mul(111,769)[;{mul(796,855)when()?$who()?,;/$mul(800,759)&what()+why()<how()*mul(20,432)why(611,106)where()* /]?$%do()who()/!^mul(691,133)who();^(:>}where()/mul(425,328))mul(702,532)?#(mul(45,856) ]/$mul(220,616)^when(){^* ?where():,mul(931,398)$;-mul(471,783)why(){:who()what()]>mul(276,590)select()when() /$(^<'mul+*&do()&)>;<mul(675,852)~;mul(128,569)!who()from(306,117){-what()mul(868,808)('why()mul(71,753)(why()~mul(250,975)?how(){;select()->mul(785,175)mul(131,573),]from():(mul(833,970)! ><<(mul(496,285)&from()~select(){mul(296,374)?[#&from()from(){{when() mul(718,993)@who()&>mul(639,708)why()where()/-<{[ how()&mul(187,633)#:]:?mul(872,562)/who()[-who()(>$%}don't()!{:*mul(82,739)select()]+ ?$?@when()mul(830,429)<what() !#^where(985,664)don't()$:,;}}where()mul(920,165)/,&:#:+'?^mul(979,57)what(740,146)},<;:[+from()-mul(481,113~when()( ~why()[,how()don't()where()^from()%from()mul(845,384)]why(),mul(884,267%what()how()why()where(358,396)mul(795,514):<what()select()'when()-mul(415,325){select()]where()&mul(876,97)@}#@^[mul(204,271)
 $'do()mul(983,642);>+;:$>mul(390,30)(&@%&'} {%mul(208,444)mul(854,207);:@where(774,785)mul(120,222)mul(885,372)$ '<[mul(476,77)select()from()mul(305,758)}#[>;,@where()~<mul(999,999)!&?mul,why()when()how()&from()+why(610,462)mul(28,578)+-,&[>how()(why(){mul(2,348)%@(~}how():mul(148,153)where()^:'why(907,374)+]mul(375,986);{]where()(!@what()]:mul(254,345))*)where()select()@?^#what()mul(94?what()!@when()select(),$?select()mul(966,420)select()/+{[;!(>what()mul(688,942)&]'^)'#!mul(363,573):$,from()select()mul(260,171)#mul(116,728)'(?mul(51,309)[!^mul(400,128))select()$-^how(740,875)where()@from()mul(319,269)select(844,13)who()#/mul(431,542)mul(794,709)- who()*do()*:)select()mul(12,579)@%])[what()&/mul(361,146)why()>:'-^&;mul(465,576))select()@%mul(101,476)who()%}' [#mul(13,38);:how()from()from()#}#&-mul(30,350)what()/+select()+]don't()!#:@;,[when()mul(303,869)when()where()]/'^!^ mul(938,614) {who()?!what(363,886)mul(439,873)>who()what()-+when()where()[why()mul?from()what()> where()who()!mul(510,226) {how()mul(353,498)]select()why()?[why()'*}(mul(709,649)~?select()*($>[from()mul(144,790)!%!mul(653,286)[<$)*+from()what(),from()mul(373,21))] select()?;+mul(601,965)what(), ,:mul(970,654)~why()(~*<+&mul(19,700)what()$what() <{<mul(850,749)when()/select()#;*&mul(561,720)from()mul(439,509)who()from()@}/,mul(390,146)who(888,573);&;@+:mul(658,554)don't()who()*how()}where(){+how()&mul(769,268)^from()?;when(518,375):'mul(570,233) )[?from()$ *mul(183,547)what(277,464) !;;mul(490,847);+)#?*where()why()how()mul(23,467)(:!mul(305,784)mul(237,433)+~[who()<:-$mul(842,162)?>({,)'how()-@mul(629,950)how()when()who()what(623,556)mul(891,30)(!don't()>who()who()%+ [)when()mul(808,962)+?</}*,&^@mul(90,782)[[mul(944,224)mul(442,115)from()where();when()+mul(162,476)mul(689,801)%><({~$#+do()}what()how()(what()*-@mul(296,108)>]^+&mul(592,463)~['%%& mul(733,447),#how()where()select()how()who()>mul(496,360)(&%*{+what()!mul(615,52)#<why(665,627)?;]$:[mul(865,200)') ')}@{}@mul(275,101)where():@</<#, select()mul(693,721)/who();from()>&*,mul(807,92)&]mul(544,513){/+who(868,321)from()mul(164,401)how()][%what()where()(+[>mul(815,703)from()(when(),*select() {<mul(20,330)mul(78,579)from(){{where()]+-*#&mul(141,703)mul(832,264)$/do()+/##>what()mul(437,310)who(226,447)mul(45,389)#&who()<mul(672,921)what()mul(9,140);)mul(19,667)};]+@why()[,)(mul(256,632)#!'!$;$where()how()mul(648,453)+'who()(?!}mul(453,188)!from()$ ]when()what(326,8)mul(96,408)mul(291,868)%~where()when()]#&^%mul(899,304)'>*[mul(659,114))what()#:+[%mul(686,605)<',,{who()^@-mul(127,293)& ;@mul(608,869)?%+*select(74,799)who()when()/^select()don't()where()$why()>why()when()%mul(752,203)-}'{^#;[%^mul(307,633)%when(970,30)mul(265,251)what(42,790)#mul(188,777)<:*& when():/when()?mul(94,809)mul(621,327)+;/*,,[select();~do()^(when()<what(554,336)mul(178,771)+%<{;;when(),/>mul(896,407),$mul(280,745)*:){^~:({where(796,413)mul(262,847)why()&&<where()$~}#mul(792,379):$!-!select()/]mul(199,174)-}!%#]mul(639,740)'select()@from()&[#
--- a/dat/24/re/04.txt
+++ b/dat/24/re/04.txt
@@ -1,140 +0,0 @@
 MMMMAXASMSXXMMSMXASXMSSMMMAXXMAXAMXSSSMMSMSSSSMMMSXMSSMMSAXMASMMMSAMXSXSMMXMSMMAMAMXXSXSXMAMMMXSSMMSSMMMSSMMSAMXMXMASXMASXXSSMSAMMXMASXMMMXA
 AAAMAAXMAMMMSAMMXMAXXAAASMSMSSMMXMXXAAAXAAXAAAAXASASAAAAMMSAMXMAXSASXSAAMSAAAAXXASAMXAAMAMASMMASAXMAMAAAAAAXMASXMXMAXAMXMMXAMXMMSSMSAAXMASXM
 SSXXXAMMAMXAMASMMXSAMMXMMAXAMAMMAXMMMMMSXMMMMMSMASMMSMMMSASASAMXMSAMAMXMASMSSSMMMMAMSMMMASMSAMXXMMMAXMMMSSMMSAMXSAMXSXSAAMMMSAMXAAMMASXAAXAS
 XMXAXMAMMMMSMSMXAAXAMXSXMMMAMAASASXSMAMXAMSXSAAMXMMAMSMMMMSASXSMMMMMAMXXXXAMAMAMASAMAAAXXSASXMMMSSMXMMAXAAMMMMMMSASASASMXSAMMXSMMSXSAMXMMSMM
 SAAMAMSXSAMXMMXMMMXAMAAXSXMXMSXMASAASMMMSMMAMSMSMMMXSAXASXMXMMXMXAMSSSMMSMMMAMSMMSASXSMSXMXMMXSAAMMAASMMMSXMAXAXSAMXSXXXAMASAASXMAAMXSXAAAAA
 XAMXAMXASXSASXMXMMSSMXMMXMASXXXMAMXMMXAAMAMXMAXXXXASXMMMXAMSXSAMMXMAAAAAAXXSSMXAXSXMAAAAXSXMXAMMSMMMXXAAXAMSAMMMMXMAXAMMMSMMMMMAAMAMAXMMXSSM
 XSXSSSMAMAMASMASXXAMMMSAXMASAMXSAMXMSSMMSSMMMSAMXMSAMAXSSSMAAMAXAAMMSMMASXMXXASMMSAMXMAMSXASMMSAAAXMXMSMMMXMAXSAMAMSSMMAMAMAXMSMMXSMMMMAAMMM
 AXAMXAMSMSMASASXMMASAAMMMSSMXMAMAMXXAMXXXXMAAXAMAXXMASXMAMXMASMSSXSAMXXAMAMAMMMXASMMXXMMSMMMXAAXXMXSAMAXXSAMAMSAMAMXAMSXSASMSAAXMAMASXMMMXAM
 AMAMSAMAAXMAMXMMMSXMMASAASXMAMSSMMSMMSSMXMXMMSSSXSAXXMAMAMXXXXAAAXMASMMMMSMSXSMMMMMMMSXAXASAMMSSMSAXAMASAXASMMXMSMXMXMAMMXSASMMSMASAMXXSMSSM
 MXMMXASMSMMSSSXMMMXMASMMSMAMMSAAMAMAAAAXAAAMXMAAAXAMXMXMXXMSAMXMXMMAMXAAAXMMASMSXAXAAXMMSXMASAAXAMMSMMMSASXMMSAMAMXXSSSSSSMMMAAAMXMMXXSAMAAM
 SASMMMMAXMAMAMMXAMAMXMXMAXAMXMXSMAXSMSSMMXMSAMMMMMSMSMASXSSMSXXXXSMSSSSMMMAMAMASAMXMSSXXAMSAMMSMSAXAXSAMAMAAXXAXAMMMMAAAMMAMSMMSAMMMSMMAMSSM
 SXSAASMXMMXSAMASMSMMMSAMMXMXSMAMMSXXAMXXSAXSMMAAAXMAAASMMSAAXXSAMXAAAXXAXSAMXMAMASXMAAMSAXMXSAMXXMMMSMAMMMSMMSSMMSAAMMMMMXAMAAXXXAAAAMSAMXAA
 SAMMMSAMXAXMAAMAXAAAASMSSSMSMMASAMXMAMMAMXMMMSMSSXMXMXMAXSMMMMSAXMMMMMSXMAMXXMASAMAMMMMMSMXMAXMSMAAMAMXMAMXMAAMASAMSSXSASAASMSMSMMMSXMAMSSXM
 MXMASXMAMASXSMMMSSMMMSXAAAXAASXSAMASAMXXXAMAAAXAXASXXXSXMSAXSASMMXSMSASMMSAMXXAMASXMXSAAXXSMASXSASXSMSMSXSAXXMXMMMXMAXSAMXMMMAAAAAMMMXSAXXAS
 SAMXSAAMSMMXAAXXMXXSASMMSMMSAMXMASASMXXMSXSASMMMMAMAMMMMXSXAMXSMSAMAMASAAXAXMMSSMMAAXXMMXAXMXSAXAMASAAAMMSASAXAXMXMMMAMAMXSASMSMSMSAAAXSMMSS
 XMAMSXMXSAMSSMMSMMXMAMXXMMMXMXASXMASXSAMSAXAMXMSASMSMAAMXMMXMSXMMAMMMMMMMMSAAAXAMSMMXMSMMMMMMMMMAMXMXMSMAMAMXSSSMAAAAXMSMAAAMAXAAAAMMXSASMAS
 MASAMMMAMAMAASAAAXAMMMMXMAMSMMAXAMAXAXSMMMMXMMXXAMAASXSMAXAAMXAMSSMXSXMMMAMMMMSAMXSSMMSAMMAXXAASAMAXAXAMXSAAMXMAXMSMXMMMXMMAMXMMMSMMMXSAMMXM
 AAMMAAMXXAMMSMSSSSXSAASMSSSMSAASXSMMSSXXAMAMMMMMXMXMXMAXXMXXSSXMAXAAXASMMSSSSXXXXAMSAMSAMSSMMSMSMSASMSAMXSMSMASMAXAASMSSMXMSSXMSAXAMXAMAMXSS
 MAMXXSXMSMMXAXXXAMXMXMMAAMMAMMXMAAXAXAMSMSSXAAAMXSXMSSSMMMSAXAMMMSXMSMMAAMAAMMMMMASXXMMSMAAAXMMXXMASMAMXMXMAMXSASMMXSAAXMAMAMAMMMMMMMXSAMAMA
 SSSSMAMMASXSSSXMXMASXSMMMMMAMXSMSMMSSMMXXAMXSSSMAMAXAAAAAAMXXAXXASAMXASMMMMMMAMAMMXXAMMASMSMMMMMAMSMMASMXMSASMSAXAMAMMMMMSMMSAMASXXAAXMAXSSS
 SXAAMAMXASXAXAXMMSMSAAAXXMSXSAMXMXMXSXASMXSAXXAMAMAMMMMMSXMAXXMXXXAMSMMMMXSASXSASXAMXMXAMMMAAAAMXMXXMASAAXMASAMAMXMASXSAAAAASASAXMXMSMSMMMAX
 MMSMMASMAMMSMMXXAMAMXMMMSAAAXMXAMXXAXMMAAAMASXMMSSXXMASXXAMMXSASMSMMMAAMSASASXSASMMXAXMAXAXSSSMSAMMXMASMXMMMMXMMMMMMMAMXXMXXMAMMSMSAAMAMXMAM
 SAMXSASMAMAXAXMMSSMXASAXXMASXMSXXMMSSSXMMMSXSAMAMMXSSMSAMMMXXAASAAAASMMMMASXMASAMXXAXMSMSMMAXAMSXXAAMAXXMXSMSASAAXSSMMMXXSSSMXMXAAMSMSMSMMSM
 SASAMMSXSMMSMAMAAAXSAMXSAXAXMAAXMMXMAXXXMXMMMAMSSMAXAAMMMASMMMXMMSSMSAAXMAMXMAMMMXXMSAXAAXMXMSMMAXSXMASMXAXASASMSMAXAXSXXMAXASMMMAMMXMXXXMAM
 SAMMSAMXMAAXXAMXSSMMAMSMMMMSMSASMAXMMMMMSASAMSMXAMXSMMMASMSAMMMSMMMAMMMMAXMAMAMAMMXMAMMMMMSAMAAMMMAAMMAMMMMMMXMAXAMMSAMXMMAMXXXMSASXAMSSMMSX
 MXMASMMMSSMSMXXMAMXMMMAAAASXAMSAMXSMASXAXMXMSAMSXMMMASXXSMMAMXAMAAMXMSMXMAXXMSXMAXAMSSMXAAMMMMMMAAMXXMASAMAXSAMMMXXXMXMAXMASXAMXSASXXXAAAAXS
 XAMXSSXAAAXSMSMSAXSSSSSMMMAMXMAXMXSXAMMMSSSSSMXMAMASAMSSMXSMMMSSSMMAMAAASMMSMMASASMXAAMMMSXXASMSXSXMXSMMMSSSSMSMXSSSMMSMXSASMAMAMAMMSMSSMMMS
 SSSMXXMMSXMSMMAMMMMAAAMXSXMMSMXMSAMMMSSMAXXXMXXSAMMMMSMSAAXAAMAMXMSASMXMXAMAASAMXAXSMSMSAMAMAAAAAXAMXMXXXAMXMXAXMXAASAAAMMMSXAMASXMAAXAXMSAS
 XXAMAXMAMMMSSMXMMAMMMMMASAXAAMAAMASXXAXMMMMMMAMSASXSMAAMMMSMMSMMAMMMSASXSSSMMMXMXMASAAAMASXMMMMSMMAXXMAXMAMSMMMXAMMMASMSMAASMMXXSAMMSSMMAMAS
 AXAMMSMAXSAMXXMXSXSAMXMAMXMSSSMSSXMXMASMMAAAMAMMXMASXMMMAXAMXAXMASXXMXMAAAXXXXXXASAMAMMMAMMMXXAAXXXMAMSSSXMASXMASXSMAXMXXSSMSMASMXSSXXAMMMAM
 XSAAXXMAMMMXSAMXSXXMMAMXXSAAXXMMAMXXMASASXSMSXSXSMXMASMSSSMAMSMSAXAASMMMMMSXSAXSXMASXMSMSXXXAMSXSASMMMXAAXSAMXXXAAAMAMXAMMAAXMXSAAXMMXXMXMAX
 MAMAMSMSSSXAXMMAMAAXSXSXAXMXMSAAMAXMMASAMAMXSAMAXMMAMSAAAMXSXMASASMMMASXSAAAXXMSMSAMAXMAXASMXMAXMAAAAXMMMMSASAMXMSMMAMMSXSMMMMMMMMSAMMAMSSSS
 XMMMMAAAMAMASXMASMMMMASMMXSXAXMMXXMAMAMMMSMAMAMSSMMAMMMMSMAMAMMMAAXAXSAAMMMSXMASAMASAMAMSMSAMXMXMASAMMMMAXSAMXMSXAXXASMXXSMMASAAAXSAASXMXAMX
 MXAAXMMMSMMAAXSAMMAAMMMASASMSXSXAXSASXSXAMMSSXAAAASXXSAMAMASXSXMSMSXMXMXMXAMXMASXMMMMSAXMASMMAMSXMAMXAXMAMMSMSAMXSXSASASAMASASMSMXMMMMAMMAMX
 XMXMXAXAMXMXSMMASXSSSXSAMMXAMASMSXSAMAAMASAAAMMSXMMAXSASXSASAAAMMAMXAMXASXAMXMASAMXAASXSMAMMMAXAAMAXSSMMMMMAXAMAXAXMMMMMASMMASAMMXAAXSAMXAMX
 XSAMSMMXMAMMMASXMAAAAAMXSXMXMXMAXAMXMSMSXMMSMMAMAMMXMSAMXMAMXMASAAMSXMMAXMAXAMAMMMSMMSASMMMSSMSSMMMAXMASAXXSXMMSXMASXMXSAMXMAMAMXXMMXMAXSASA
 SMMXASXXXAMASXMSMMMMMMMXMAMAMAMSMXMSXMASXMAXXMASMMMMMXMMXSMSSXXXMMMXMSSMMSSSMSMSMAMXXMAMAXAAXXXAAAMXMSAMASMXAXAMASAMXSAMXSMMXSXMSSMSSXMMSSMX
 AAMSAMXAASXMXASXXXXMASXXMASMSSMMXAXXAMAMAMASAMASAAAMXAXSXMAAMMMMSMMAAAAAAAAAMXMAMXSMXMASXMMASXMMSXSMXMASAXASMMSXAMASAMXSAMASAMMAAAMSAASAMASM
 MSMMAMMMMMASXMASMSXMSSXSMXXMAMAMMMMSXMAXXMXSXMASMSMSSMMSAMMMXSAAAASAMSSMMSSSMMSSSMAMXSASXXXAMAMAAAAXXSXMXXXAMAXMASXMMSSMMSAMASXMSSMMXMMAXMMM
 XMAXAXASXMAMXXMASAAMAMMXXMASASXMAXAMASASMMASXMXMMXMAAXAXAMXSASXSMMMXMAXMXAXAAAAAAMAMXMXMXMMXSAMASXMMMMMAXXMXMASMAXXAXMMAAMXSAMAMXMMMXSSSMSAM
 SSSSSSSSXMSSMAXXASXMASXSXMASAMASXSMSMMSAAMAMAMXMSMMSSMMSMSAMXMMMXMMAAMMSMSSSMMSSMMMSSMSMSAAASXSXXXXXXAMMMMAAMXXMAMSMMSMXMXAMASXMSAAMMMAMASAS
 MAMAAXAXMMAAXXMMMMXSXXAMAMAMAMAMASAAAXMXSXMXAMAMAAMMAMXAMMXMAAAAAMSSMSAMXXAAXAXXMXAAMAAAMMXAMXMASMMSSMSAAXMSSMSMMMSAAMMMSMASXMXAMSMSAMAMASXM
 MAMMMSMMAMSSMSASXMASAMXXAMAXMMASAMMMSXMAMXMSSSXMMMMSSSMMSMMSSSMMXXAAAMAMSMMMMXXAMAMXMMMSMSMXSAMAMAAAAXSMXSAAAASXXAMMMSAAAXXMASMSMXXSXSMSXXAX
 SASAAAAMXMAAAXMAAMASXXASXSMSXXXMAMSMXAMASAXAAXMMSAAXXXXXMAAAMAXAXMMMMXAMAAXSXSSSMAMXXSXAAAAASAMMSMMSSMSAAXMMMMMAMSSMASMSXMXMXMAAASXMASAMMMSM
 SXSMSXXMSSSMAXXXXMXMXAAXMAAAAMMMSMAAXXXASAMMSMMAMASXXAMMSMMXSAMSMXSAMSSMMSMMAXAMXSMMMASMSSMMSAMAMAMMMAMMMXXAXAMXMAAMASAXXMAXMMSMSAXMAMAMMAXA
 SAMAXAMXAXAAAMAMXMXXSMSXSMMMASAAXSMMMMAAXAMXAMMMSMMMMSSMAMSMMXSXAAMAMAAMXMAMMMSMAXAMSAXMAMXXSAMAXXXAMSMMMSMXXMSMMSSMAMMMAMAXSAMXMMMMAMXMMMMA
 MAMAMMAMMSMMMAAAMSMMMAAAMXMSAXMMXAXMAMAMMAMSXSAMAAAMXAMMAMXAAMMMMMXSMSSMASASXMAMASAMMXMMASAMXMSMSSMAMXAXXAMSSMMXAMXMASXSXMAXMAMAMXMMMXMSSSSX
 XAMASMSAAXAAXXMXMASXMAMXMAAMAXMXSMMSMSASXMMMMSASMSMSXMXSMSSMMMAMMSAMXAAMASMMASXMASMMMSXSASASAMSAAXSAMMMMMASMAAMMMSASXMASMMSXSAMXMAMXSAAAAAMX
 SAXMMXMMXSSMSSMASASXSMSMSMSXSMSASMAXAMASAMAAASMMMMAXMXAMXXMMASASAMASXMMMAMAXXMAMAXAAAXMMXSAMXAMMMMXMXXSASMXMSMMSASXMMMMMAAMASMMSSMSAXMSMMXMM
 AMSSMMSMAMMMAASXMASAXAAMXSXXAAMASMMMXMXMMSSSXXXSAMXMAMSSSMXSASMSASXMMASMASXMSSSMSSSMSSXSAMXMMXMAASXSMXSAXXMAMXAAMSMSASAAMMSXMAAXAMMXXAXXXAXA
 MXAAAASAMXAXSMMMSAMXMSMSXMMMMXMSMMXAMMSXXAAMXMSXMMSAMSMAXAAMAXXMXMMMXMMAAAXAXAAAMAMXMAMXSASXSASXXSAAAAMAMSASXMASXSASASXSAXXASXMSAMXMASMMSMMS
 XMSSMMSAMSMXMXSXMSMXXMMSAMXXMMMXAMXSXAAMMMSMXSAMSASXXMMSMMMSAMSSSSXMAXXXMMMSMSMMMSMMXMASAXMAXASXAMMMSXMAMXAXMASMXMAMAMAMXAMXMAMXMSXSAMAAAMSM
 XAAAXXXXMAXAAAMAAMXXAMASAXXXMASMAMSAMXSMXXMASMXMMASAMXAMAAXMASXAAAASXSMSAXAAAAAAXMAMSXMSMMMMMXMMMXXXAXMASMAMSSXMAMSMSMAXAXMASXXAMXAMXSSSMSAX
 MSSMMSMMXSSSMMMMXSASMMASAMMXXMXMMXMASAXXSXMSMMASMAMMAMASXMMSXMMMMMAMAAASXMSSMSSMSMSMSAMXXAAXMMMAXXSXMXXAXXMMMMMSMMAAXMASMSSMMMSMMMSMAXMAXSAS
 AAAXASAMAMXMAAXSMXMSAMXSMMASMMMASMSAMXSXSAXMASXSMAMXASMXMAMMAXAMMMSMMMMMAMAXMAXAXAAXMAMSSMSMSAXSMXASXXMMMXMXXAMMMMMSMSXXXAAAXAAAXAMXXMMMMSAA
 XSAMMSAMSXASMMMSMAXSAMMSAMSAAASAMAMXXAMMMMMXMMAXXMSMAAMAMMASASXSXAAAAMXMMMAMMAMMMSMSSSMMAAAAXSMAAXMASMAMAMXAMXSAASXXAMXMMSSMMSMSMAXMMXSXMMSM
 XMAAASXMMMMMAAXXSXXSXMASAMXMSMMASXSMSMSSSMAASMSMXXAXMAXAMXAXAMMMMXSMMXSXMMSSMXSXAAAAXMASMMMSMXSSSSXMXSAXSXSMSMSMSSMMXMAMAMMMMXAXXSMXAAAAXAMS
 XSAMMSXMXAMSSSMMAMASXSXMAMXXMXSMSAXAAAAXMMSXSAAAMSSSMMXSAMSMMMAAAXMAMASAMAMAXMMMSSMSSSMMMSXMAMAMXMAMXMMXXASAAXMXXMAMAXAMXXAAMXMSAMAXSMSSMMSX
 MXSXAMASMMMAAXXMASMSXMASAMMXMAXAMAMSMMMSXAXAMXMMMAMMMAAMMXMASXSMSAXAMASAMXSSMSAMXXXMXXXAMAAMMMMMMSMMMAMAMMMSMSSMSXSXSSSSMSSXSAXMAMSMMAAXAXXM
 MAMMASXMAXMMMMMSAMXMAMAMAASXMAMMMXAMXSAAMXXAAASMMMSAMMSSXAXAMAXXAMSMMXSMMXXMASMSASMMMXSASMSMXMAAAAXAXAMXSXAXMAMASAMAXAXAMAXMSMSMSMXAXMMMSMAA
 MASXMXMMSMMXSAXMAXSASXAMXMAAAMSXAMXXAMASMMSSSMSAAXMASAAMXMMMSXMXMXMXAXMAXXAMXMAMASAAMAXMXXXMASMMSSMXXAMXSMMSMAMMMAMAMMMSMAXXMAXAAAMXMASAMMSM
 SXMAXXSAXAXASASXSMMAMSMMXMASMXMASMMMXMAMAAAAAASMMMSAMMXSAMXXAXAXXAAMMSXMSMMMXMXMSMMAMAXSAMXXAXAXXAAXSSMXMAMXMSSSSSMXMSAXMMSAMAMSMSMXSAXXXAAX
 SASMMMMMMMMMSAMXAAMAMAXSXMXXAXXAAAAAMMSSXMMSMMMMSXMASXXSMXSASMSMSSSSMAMAXAASXMXMMMMXMAXMAXASMSMMSMSMAAXXSSMXAXAAAAMAAMMMASAMXAAAAXAXMASAMSSS
 MAMMASAMASAMMAMSSMMSSXMMMMMAXXMMSMMXXXAAASMXAAXAMMSMMMXMAMAMXAXAAAXMXAMMSSMSAMAMSSSSSSSSXMXMAAMAAAAMXMMMMASMSMMMMMMMSAMXMMAXSXSMSMSMXAAXXAMX
 MXMXXMXSASASMMMAAXAXXMSMAXAMMSAMAMSSSMMSMMMMSMMMSAMAAXAMAMMXMSMMMSMMSXSAAMAXMXASXAAAAAMXMMSMSMMSMSMMAXAASMXXXAMMXMXMXMAMSSSMMAMAMAASMSSSMMSS
 MSSMMAXMASXMAMMSMMMMXAAMSSMSMXMXAMAAAAAAMXXAAASAMASMMSMSXSXMAXSSXMAXXAMMXSMMMSMSMMMMMMMASXAAAAXMAMMXSMXMSXMMXAMMASAMSMSMAXXAMXMAMSMXMAAXAAAX
 SMAAMXXMAMMSAMMXXAAXMMSXMAAAMXSSSSMSMMMSSXMXSSMAMAXAMXASXMXSSMAXAMSMMMMMXSAMXAAXMXSMAXSAMMMSSSMAAXMAMASMMMAAMSMSASASAAAMMMMSMXSAXAMXMMSMSMMS
 SSSXMMMMMXAMASAMSSMSMAXASMSMSAMMMAMXMAMXXMMAXXXMMSSMMASXXXAMXMMMXMXASXXMASAASMSMSMASMMMXSAXAAAAMSSMMSMMAASXSXXAMAMXMMSMSSMAXSMMXSMXXMSMAMAAA
 MAMXAMSASMSMXMAXXXAAMMSAMAMXMASXMSMASASXAAMXSAAMAMXMASAXMMXSAASAMXSAMAAMASXMAAAAMXAMXAAASMMMSMMMXAMXAAXMXMAMAMXMMXSSXAASAMXMAMSASMSXMAXAMMMS
 MAMMXMSASAMXSSXMAMSMSXMAMAMMSXMMSAMASMSMMSAMMMMMASAMXXMAMAASXMXSAXMMMSSMXMAAMSMSXMMSXMMMSASXAXXXMAXSSSMMAMXMAMXMMAMASMXSXSMSAMXAMAAXXASMXSAA
 MXSMAXMAMAMAMAMAXAAAAAXXMAMXSAAXXMMXSASMAMAMSAXSASASAXMAMAXXMMMXMMAXAAAMMSSMXXXAXSXSMMAASMMSXMXMSSMAAMMSASAMAMSXMASMXSAMAXAMXSMMMMMSMASMAMXS
 XXAXXMMXSXMMSAASXSMSMXXASXSASMMMSXMXMAMMXSXMSAXMASAMAXSASMMXAASMSSSMMXSMMAAXAXMSMMASXMMXSAMMSMAXAXMMMMMSSSXSAMXASXSXAMMMSMXMAMAMXXAAMMMMAMAA
 MSAMMXSXXXAMMMMMAAAMAMSMMMMXSXAAXXXAMSMXMXMXMSMMAMAMAMMXXAASMMSAAXAAAMXXMSSMSSMAAMAMAMMXSAMAAMMSAXSXXMASAMXSXSAMXMMMSMMXXAAMSSSMASMXSAAMASXS
 XAAXMASAMSMMAMMMSMMMAMSAAXMAMXMSMMMSSMMMMSXXAAXMXSAMXSAMMMMMSAMMMSSMMSMAXXXAXAMSXMASAMAASMMSSSXAMMSXMMXXAMMMAXAMAMXAMAMAXSAMXAAMAXMASMMSASAM
 MXAMXAMAMMASASAAMMXSXASXMXXMSSMXXAAXXMXAMMMMSMSXASASASXMAXXAMXMAMMAMMAMMMSXMXMMMMSMSMMMAMXXXAMMSMAXASXMSSSMMMMMSASAMXAMXMMASMSMMXSXMXAMXAMXM
 ASXAMMMAMXMMAXMXSMMMMXMAMSMXMAAXMMMSAMSXXAAMAMXMASAMXSAASMMSMMSSXMAXSXMASASMXSAMXSXMASAMXSSMSMAAMXSMMAXAAAMXMAMSMSASMMXSMSXMAXAXAAAXSSMSSMMM
 XAMMSXSASAAMMMSSXXAXSSMAMAAASMMMMXMSAMAXSSXSAXAMXSXMMXMMMAAMAXAMMSSMSASMSAMXAMASMMSMAMASAMAAXMSSSXMASXMMSMMMMMXXAMAMXAASASXMASAMXSSMMAAAXAAM
 AMSAAAAAMMSMMAMAMSXMSASMSMSMSXMAXMAMAMMXAMASAMSMMMASXMSAXMSSXMASAXAASAMXMMMMXMAXAMXMASAMASMMMMXMAMSAMAXXXAXSASMSXMMMMMMSAMAMXMXMXXMASMMMSXMX
 MXMMSSMSMMMXMASAXSMMSAMXAAMASXMMMSASMMXMASXXMAMAASAMXXSASXMAXXAMMAMMMAMASXSXSMMSAMXSASAXXMAAXAAXSAMASMMSSMMSAMAMMXMASMXMAMXMASAMXASAMASASMSX
 XAXAXAAAAAMMSMXMMXAXMASMMSMAMXSAASASXSAMMMMMXSMSMSMMMMMMMAAMMMSSMXXSXSSXSAMAMAMAXMMMXMASXXMMMMXXMAMASXSAMXASMMSMMASASXMMAMXSXSASMAMMSXMASASM
 SMSMMMSMSMMMASXMMSAMXSMXXMMAMAAMMMAMASASAMAMAXAMXXAAXAAAXXMXAXMAMXAAAASMMMMAMAMSSSXSXMAXMASMSMSXSAMAXXXXAXASAAXAMXSAMAMSMSAXAMXMXAXMAMMXMMMX
 XMAAAAAXXMXSAMMAAMAMXXAMXMXSMXSSSMSMXMAMMMSXMMMXASMMSSSMSAASMSSXMSAMXMMXAMXXSXXMAXASMMMSMSMAAASASXMMSMMXMMASMMSSMMSAMAMAXXMMSMMMMMXMMAMASXMA
 SXMMMSSSSSXMMMSMMSSSMMAAASAMXMMAMAAAXMXMSAMASAXMMMSAAAAASMMAAMXXAXMXSSSMSSMXAMXMAMXMAAXMXMMSSMMAMXSAAAAMXSMMXMAXMASASXSXSSXMMSXAASXSMASASASX
 XAXSAXMMXMAAXAAAAAAAXSMSXMASMMMAMSMSMASXMASAMMASAAMMMSMXMASXMASMMMSAMXAAAAXMMAAMAMSSSMMSAMMXMAMXMASXSMMAMMAMSMMMMMMAMMSAXMASAMMMMSAASXMASAMA
 SSMAXSMSASMMMSSSMMMMMAAMMSSSMSSXXXMAAMMASXMMXXXSMSSMAAXASAMAMXXAMAMAMSSMMSMMSSSXXSAAASXSAXXAMAMAMXSAMAXSMSAMSAMSMXMXMASMMSAMXSAAXMXMMMMXMMMM
 XAMMXMAMXXXXXMAMMXMSXXMSAXAXAAAMSAXXXAMAMXAXMMMSMAAMSSSMMSSXMMSAXSSSMXXAMXMAAMAXSXMMMMMSAMMMSASXSAMMMXMXAMMMSXMAAASMMASAAXSMXSMSMSAXAAMXSXAA
 MSXXAMAMSSXSAMXMMSAMAMXMXMXMMMSAMAMSSMXSAXSMMAAMMMSXXAAXAMMASAAXXXAAMSMSMAMMXMAXMAMMMSXMXSAASASAMXSXMMAMSMSASMSMSMMAMXSMMSMMAMAXXSMSXSMAMSMS
 MAMXSMXSAAXXAAXXAMXXAMAMSMSMMMMMMMMXAAAAXMXAXMMMSXMMMSSMXSAMXSMSMMSMMSAMMSMSMMXXMAMAXMASAAMXMAMXMAMASXAAAAMMXAAAAXMSAMXXMMMMASXMASXSAMMAMXMX
 SMMAMXXMMXMSMSSMXSXMASASMASAAAAAMASMMMMSXMSAMASAMMXAAXAAAXMSXXXAXAAXXMAMAAASASXSSMSMMXAMMSXXMMMAMMSAMSMSMSMXMSMMMXXXAMASXMAXXMAMMXMMAMSXSSMS
 AXMASMSMSXAMSAXXMAMXXMXXMMMSSSSMMMMASXMXAMASMAMASASMSSMMMSSMAMSMASMSMMSMMMSMAMAMSASASMSSMAXXAASXXMMAMAMMMMMSAAASXSMSSMASXMSMMXSMMASXSMMXAAAM
 MXMXXAAAAMMMMMSSMAMXSMMXSAAXXMAXMXSASAMXAAAXMSSMMXAAMAAMAXAMXMAMAAXAXAAXSSXXMMAMMMMAMAMAMAMXXMMSMSSMSMMSAMAMSMXMAAAAXMAMXXXAAAMASASMAAMSSMMM
 XSXXMSMSXMAAAXAAMAMAAAMASMSSXMAMSAMASXMXMMMSAAXMSAMMSSMMSSSSMSXSSMSAMXSAMXXMMSXSXMMSMXSAMASXMSAAMAAXXMASAMXMASMMMMMMMMASMASAMXSAMASMMMMAAMMS
 SAMXMXAMASXSSMSASASXMMMASMMMXMASMAMAMAMAASXMAMASAMXAAAAXMAAAXAMXAMSAMXXAXXXAXAAXAXAMXASMXMMAAXSXSSXMXSASMMXXAMXXSSMXXSMXAXSAXAMMMAMXXAMSXMAA
 XMSAAMAMAMMAXAMXMAXXAAMXMAAAAMXXXXMASASMSMAMXMSAMXMMSSMMMMMSMXXXAMMSAASMMAMSMXSXMMSSMXSAXSMMMMXMAXAXMAXMASAMXMMAAAXMASASMXSAMSXMMSMXSXMXSMXS
 XXMMXXAMAXXSASAXMAMSSMSSSXMSSSSMMXSXMASXAMMMAMXMXAXXAAXMAMAAXXMXAMXXMXMXAAMAMAXAMAMAMAMXASASXMASMSSMAMASXMSSXASASMMMAMAMSAMXMMAMAMMAAXAXXXAM
 MMSMMSSSSSMXAXMMSAMXAAXAAMXAMMMAAMMSMMMMMSMMXXMASXSXSXMXAMSSSXSASASMSMXMSMSAMXSXMXSMMXSAMSAMASAMXAAXSXAMAAAXMAMAAMASAMMMMXMAXSAMASMXMMMXAMAS
 AAAAXAMXAAMMMMMAXAXSXMMMMXMAMAMMMMAMXASXXAASMAMAXMAMXAAMXMAAXXAAXAMAAAXMAAMMSXMMMMMMAAXMXMXMMMSMMSMMXMASASMSMSMMMSXSXSAAAXXXXSAMASXXXAMSSMSA
 MSSXMASMSMMMSAXXMSMSSSXXXXSXMXSXXMAMXAMXSSSMMAMMSSMMSMMMSMXSXMMMMAMSMSMSASMXMAMAAAAMMMSXMXSXMAMXXAXMMSAMXXAAMAAXXMAXASXSSMMMMMMSAMMMSXMAXMXM
 XAAAXAMXMASAMSMSSMAMAXXMMMAASAMXMSMSASMMAXMAXXSAAAAAXMAXAAAXMSAXXXXMMXAMAMMXMMSSSSMXAAXAXAAAMSMMXSAXAMASMMSMSSSMMMMMMMXMAASAAAXMASAAAMMSSMAX
 XMMSMASXSAMXSAMMAMXMMMXAAMAAMASAAMAMAXMAXMSSMMMMSSMMSSSSMSMXAXASXSAAMMSMXSXMXXAXMMXSASMMMXSMMAAXAXXMXSAMAXMAMAAAAAXMXMMMXMMMXSSSMMMMSSMXAMXS
 AXAAMXMAMXSMMAXSAMXMXMMSXSAXSMMMXSAMXMMSXMAMAAAMAMXAMAMXXAMMSMXMASMMXMXSAMAMSMAMSAAMXXAMAMXAXSXMMMSAMMAXSAMXMMMSSMMMASASASXXXAMMAMMMXXXXXASX
 SMSSSXXMMAXASAMSAMXXAXMAXXMASXSAASMMXAMMAMXSSMSMSSMXMAMXSXSAASXMXMXXSXAMXXAMSAAAMMSSMSMMSSSSMXAASAMMXMAMMASAXMAXXAASASASASAXSASXXMAMSMXMXMAX
 XAMXMMXAMMSXMXXMXMSSMSAMMXMXMAMMMMAXXXAMMMMXAXXAXAAXSMSMSAXXXXMASXMASMMMSSMMSMMSMAAMMXAXMAAXASXMMASASMSMSAMMSMSSMXXMAMAMAMAMSAMAMMAXAAASAXMS
 XMSAAASXSAAMXMXSASAAXXAMAMSAMAMXSSMMMMSXMSMSSMMMSMMMSSMAMMMSMXMASAMAXAMAMAMASXMAMMMSASMMSMMMXSMASAMXMAMXMAXXSXMAAMSMSMSMSMSMMXMASXMMMXMSAMXX
 SSXMSXMAXXAMXAMAXAMXMXMMSASXSMSAAASXAAXAXAMAAMMAAAAAXAMMMXAAAXMAXXMMSSMXMXMAXASMSAMMMMAASXAXXMXAMASXMAMMXSMXMASAMXSAAAAAAAXAMXMAXXMASXMXXMXX
 MASAMAMXMASXSSMSMMMSASXXMAMAXXMASAMXMMXMMMMMSMMXSSMSSMMASMSSSMMSXMXMXMASMXMMSMMSSMMAMXMMMMXXAMMXSMMMSSXSAXAASAMXMXMSMSMSMMMAXXMXSASMSAXAXMXM
 MXAMSXMXXAXXMASXAXAAAAMXMAMXMXMXMMSMMMXAAXXAMASXAXAMAMSMSAMXXMAXMSAMAXMASAAXXAMXSAXXXASMSMSSMXXAXXAXXMAMASMMSAMMXMAMXMXXAMXAXMAMSAMAMMMSXSAA
 SMMXAXMMMASASMMSSMXSMMAXSSMMMSMXMAXMAAXSMSMXMAMMMMMSAMXAMAMXXMAMAMAMAXMAMXSMSMMASMMSXMSAAAAXMASMMSMSMMAMXMAXMAMXAXMSAMASAMSXMXSMXSMAMXXMAMSX
 AAXSMAMASMMXMAMAMAMMMXXAMAMSAAMSMSSMMSMMASASMSMMAAXSMSMSMXMAMMSMSSSMAMMASAXAAAMMXXXMASMXMMMXSMAAAAAAAXXXAMXMXSAXAXAMXMASXMAAXAXMAXMXSXAMSMXM
 MSAXMAMXMMMMMMMXMAXAXMAXSAMMMMSAAMAXAXAXAMSASAAXMSMMXSAAXXXSAXXXAAAMAMSAMXSXSMMAMMASXMAAMASAMXSMSSSSMMSMSMAMXMAMSMSXSAAXMXXSMSAMSSMXMASAMASM
 XMASXSSSMSXSASASMXSMMMAAMMSAMMSMSMMMASXMMXXXSMSMMAASAMMMMSAMAMSMMMMMSXXASASMAXMASXAXXMSMSAMASAXMXMXMXAXAAAMMAMAMXAAAXMAXXSAXAMXAAAMASAMAMAMX
 XMSXAXXMAAAXAMAMSASAAMXXMXSASAMXXAXXXAMXSAMXXMXAMSSMASXSAAAMAASXSASMMMSAMAXMAMSAMXAMMMAMMXSSMMXSXMASMSMSMSASASXMMMMSMXSAAMMMXMMMSMMMAASXMXSX
 XSMMXMAMMMSMMMMMMSMMMSAASAXASASASAMXXAAAXASAXSXSMXXXXMASAMXSXXSAMASAAMMXMXMMXXAMXXXAXSASAXMAMSAXAMXSAAMAAMAXMMMMXXXXAAMMSMXAXXXMAMSXMAMAMAMX
 XXXAAMXAAAMXXMAXMMSXAMXMMASXSAMMSASMSMMMSXMMSMAMXMASXMXMAXAAXSMAMASMMSAMMMSAMXSMSSSMXSMMMSSSMMXSAMMMMMSMSMMMMAAAMMSMMSSXMAMXMSXSXXXAMASASAAS
 MSMSXSAMXMMMMMSMAAXMAMAMSXMXMAMASAMXXAAMSAMXAMMMAMSMMAAMXMSMMXXXMAMAXMASAAMXMSAAAMMMXMSAAXAMXAASMMXAAXAMXAAAXSMMAAXAMAMXMMXMASAMASMXMAMASASA
 SAAXMMXXAAAMAAXSMMMXAMMMMASXSAMXMSMSSSSSSMMSMSXSSXAXMXMSXAXXAMMMMXSXMSAMMSMAMAMMMSAMXASMXSSXMMXXSMMMSSMSSSMSXXAXSAASAMXSMSMMAMAMAMAAMMSAMXMM
 MMSMAAMSMSSSMSXSXMASXSMMSAMASAMMMAXMAAXAMXAAMAMMMMMXMAAXMXMXXXMAAAAXMMSMAXMXSAXMMXXMXXMMMSXXXXAAMXSAMAAXAMSMXSAMAMAMAMAMMAAMMSMMMSSXMMAMSSMX
 MXXXMMXAAXAXAXASXXXAXAAMASMMMMMSSMMSMMMMSMMASASAXXMAXSMMMSMSMMSMMSAMXAMXAXAASXXSASMSMXAXXMAMXMMSMAMASMMMMXAMMMXMMASMMMAMXSSMXAAXAAXAMXASAAMS
 XSAMSMMMSMAMXMAMMMMSMSMMAMXSAMMAAXMASXXMXAMXSMSASAMMMXAAAXAAXAAXMAMSMSSXSMMMSMMMMSAAMSSMSXXMAAAMMSSMMAAMXMMSSMAAXXMAXMAMMAMMSMXMMXMXSSMMMSMS
 MMAXAAMAXMMMXMSMAAAXAMXMXMAMASMSSMSMSMXSMMMAXAXXXXSXAMSMSMXMSSXSASMMAAMAXMSAXAASXMMMMXMAMMAXXSAXAXAASXMMAMXAAMXSXMXSMMAXMAMXXSAAXASMMAAAAXMX
 XSMMSSMAXXASMMXSSSSMAMSSSMXMSMMXAAMXMMMSXAMAMMMMSXMMSMXAMAAMAMXSMMSMMAMMAMMMMSMXAXXMSAMAMMMXAMXMMSAMXSXMASMSSMXXAXAMXMAMMAMMASMMMMAASXMMSXSX
 XMSMAAMMMSMSAAMAXXXXXXAXMXSXMASXMMMAAAASXSMSMAAXMASAMXMXMSMMAMMXAAXXSXAMSSSMXMSSMMSMSXXMSAMXSAAAMMAASAMSAMXAXMASXMAXAXSMSMSXAXMASXSXMASXMASA
 MAAXMMASMMMSMMSMSMMXMMMSMAMASMXMASMXXMXSAMAMSXMMSAMXSMMSAMMSSMSSMMSXASXXXAAXXMASMAMAMAMSMXSAMXXXASXMAAXMAMMSSMASXASMSMXAASAMXSSXSAXMSAMAMAMX
 XSASXSAXAXAXAMXXSXAAMAAAMASXXMAXAMXAMXMMAMAMMMSXMASMSAXXAXMAMXAAAAAMMSMMMSMMXMAMMMMAMAMAAAMMSMSMMASXMAMXMMAMAMAMXSAAXAMSMMSSMXMAMAMAMXSXMASX
 XAAAAMXSMMMSMMSAMXSSXMSMSXXAASXMMSSMMMASXMASAAXASXMASXXMXMMSSMSSMMSAXSASXAAXMMAXAAXMSMSMSMMXAAXXSAMXSXSAAMXSAMAXSAMSMSMASMAXAAMXMAMXMAAASAMM
 SMMMXMMAMAXAAASMXXAXXMAMMASXMMXSAAAAXSAMAXAMMSSMMXMAMAMXMSMAMMMXAXXMMSAMXSXMMSSSMXMAAAMMAMXMMSMMSASXMAMMXMAXMSSMMAMAAXMASMMMSSSMSSSMMSSMMMSS
 MASXMASASMSSMASMMMAXSMMSMAMMAXAMMSMMMMASMMSSXMAXAXMMSSMAMAXAXXSMMMSAMMAMXXAXAAAAAAMSMMMAMMSAAMAASAMAMSMMSMMSMSAXSAXMXMMXSAXAAXAXXAXXAXAXAXAX
 SAMXXMSXSMAAMASAXMAXXAASMMMSXMXSAAAAAAXAXAXAAMSSMSAXMAXSSSSMSMMAMXSMMSMMMSMMMSSMMMXMAAMAMAMMXMXXMSMXAAAAXSXAXSAMXXSSMXMSMAMSXSMMMMMMMSMMMMSS
 MASMSAMXXMSMMASAXMMMMMMMAXAMXSMMXSSMSMMMMSMSMMAAMSASXSMXAAAAAMSAMMMAAAAAXAAAXMAXASXXXMSAMASXSXMSAXMASMMMSMSMMMXMMSAXMASAXAMXMAXAXAAXMAMAAAXS
 AAAXSAMXMMAMMMSASAMMAAMSMMASASAAXMAAAXAMAMAAMMMXMSAAAMSMMMMSMXSXSAMMMSSMMXMMSXMASMMSXMSMSMSMSAMMAMMAXAMSAXAXMAMAXMASXXSMSXSAMASXSSSXXASMSMMS
 MMSMMASMASAXXXMMXAXSMMXAASAMXSSMSSMSMSASAMSMSXXAAMXMAMXXXSAMXXMASMMSAAAMSSXSXMAXXXAAAXMXAAXXMAMXAMMSSMMSMSSSSSSSXMXMXMMXXMSMMAMAXMXMSXMAMXAM
 XAAAMAMXMMAMSASAMSMSAXSAMMASMMAXXAAMAMMMAMXXXASXSMAXMMMMMMMSMMSXSAAMXSMAAASMAXSMSMMSXMXMSSMASXMSSSXMAMAXXXAXAAAMXMAXAAMXMAXAMSSMXSAMXAMMMASM
 MSSSMASXAMAAXAMXSAASXMAAMSXAXSAMMMAMXMAMXMMAMMMXAMXMXAAAAAXAXASMMMMSMXMMSMMXAMXAAAMMXMAXAAMXMAMXMXXSAMMSSXMMMMMMMSSSSMSAAXSXMMAMXMAMMAMXAXMA
 MAAXMXSMXMMSMXMXSXMMMSSSMXAAAXASXXASMSSSSSMXMASXMMAMXSSSSSSXMASAAXXXAXMAXMSMSSMSMMAXAXMAMSMSSMMAMAAMASMAMAXAAAMSMMAAMASXSMAXMSAMMMAMXMMASXSX
 MMSMSXMASXAAMAXXMMMSAMAMAXSMMSMMMSXSAMAAAAMAMMXAASASAMXXAAMAMSMXMMMMSAMXSAAAXXAAXXMSXSASAAXXAXSAMSSMMMMAMXXMSMSAAMAMMAMXXAMMMMMMSSXSAMXAMMXA
 MAAAXASXMMMSAMXXMASASMAMAMXAXXAAXMAMMMMMMMSASXMMMXASXMXSSSMXMMASXXSAMSSSMMMSMMMXSAMAAXAMMMXMAMXAXXAAAMXASXSXAMSMSMSSXXXXMSMSMMSAMXASMMXAMXMX
 SSMSMMMAASAMASXMAMSAMXMMAMSAMXMXSMSMMMSAAXSXXXAASMMMMAMXAMMSMMMMMXMASAMAAAXMAMSASXMXSMXMXMAMXMSMMXSMMSMASAAMXMSXXAAAMSSXAAAAAXMASMXMAXXXMAXM
 AAMXASXXMMASAMAAMXMMMASMSXSAMXAAXAAAAASXSXXAXXSASAMAASAMXMASAXSASASMMMSMMMXSAMAAXMMMXMAXMSAMAMAAMAMAAAMAMMMMSMSXMAMMSMMASXSSSMSMMMXMAXMAMXSA
 MMMSAMXMXMAMXMMXXMAASXMAXASASXMMSSSSMMSAMMMASAMMSAMXSMSXAMASAMSASASMAXXMASXMASMXMXMASMXSASASXSSSMASMMSMASXASAASASXXXAAAAMXAXXAASAMXMAMSAXAAA
 XXMMAMXXXMASMXMASMSMSMMAMMMXXXMMAMXXMASAMXSMAMSAMXXXXMMSXSXMXMMXMXMXAMSSSSXMASXSXMMMSAAMXMMMXAMMMMSXMAXMSMSSMSMXMASXSSMXSMAMMSMSXSXMAMSAMXSM
--- a/dat/24/re/05.txt
+++ b/dat/24/re/05.txt
--- a/meson.build
+++ b/meson.build
@@ -1,19 +0,0 @@
 project(
  'aoc',
  ['cpp', 'c++']
  version: '0.0.0',
  default_options: [
    'c_std=c2x',
    'cpp_std=c++23'
  ]
 )
 executable(
  'aoc',
  [
    'aoc.cpp'
  ],
  include_directories: [
    include_directories('.')
  ]
 )
--- a/sol/24/CMakeLists.txt
+++ b/sol/24/CMakeLists.txt
@@ -1,24 +0,0 @@
 set(HEADERS
    aoc.hpp
 )
 set(SOURCES
    "aoc.cpp"
    "day01.cpp"
    "day02.cpp"
    "day03.cpp"
    "day04.cpp"
    "day05.cpp"
    "day06.cpp"
    "day07.cpp"
    "day08.cpp"
 )
 add_library(aoc24 STATIC ${HEADERS} ${SOURCES})
 target_include_directories(aoc24
    PRIVATE
    ${PROJECT_SOURCE_DIR}
 )
 target_compile_features(aoc24 PRIVATE cxx_std_23)
 target_compile_options(aoc24 PRIVATE ${BASE_OPTIONS})
 target_compile_definitions(aoc24 PRIVATE ${BASE_DEFINITIONS})
 target_link_libraries(aoc24 PRIVATE aoclib)
 source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${HEADERS} ${SOURCES})
--- a/sol/24/aoc.cpp
+++ b/sol/24/aoc.cpp
@@ -1,34 +0,0 @@
 #include <span>
 #include <expected>
 #include "aoc.hpp"
 #include "ctre.hpp"
 namespace aoc24 {
 auto entry([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    using namespace aoc::types;
    u32 day = 1;
    if (args.size() > 1) {
        if (ctre::match<"^[0-9]+$">(args[1]))
            day = std::stoul(args[1]);
        else
            fmt::print(stderr, "arg: {} is not a number\n", args[1]);
    }
    switch (day) {
    case 1: return day01(args);
    case 2: return day02(args);
    case 3: return day03(args);
    case 4: return day04(args);
    case 5: return day05(args);
    case 6: return day06(args);
    case 7: return day07(args);
    case 8: return day08(args);
    default:
        return aoc::make_error(fmt::format("day {}", day), std::errc::not_supported);
    }
    return {};
 }
 }
--- a/sol/24/aoc.hpp
+++ b/sol/24/aoc.hpp
@@ -1,40 +0,0 @@
 #ifndef SOL_24_AOC_HPP
 #define SOL_24_AOC_HPP
 #include <span>
 #include <expected>
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 namespace aoc24 {
 auto entry(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day01(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day02(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day03(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day04(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day05(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day06(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day07(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day08(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day09(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day10(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day11(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day12(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day13(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day14(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day15(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day16(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day17(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day18(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day19(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day20(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day21(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day22(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day23(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day24(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 auto day25(std::span<char const*> const& args) -> std::expected<void, aoc::error>;
 }
 #endif
--- a/sol/24/day01.cpp
+++ b/sol/24/day01.cpp
@@ -1,68 +0,0 @@
 #include <numeric>
 #include <algorithm>
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 auto aoc24::day01([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    constexpr auto filename = "./dat/24/re/01.txt";
    std::ifstream strm{filename, std::ios::in};
    if (!strm.is_open()) {
        return aoc::make_error(
                fmt::format("Error opening file: {}\n", filename),
                std::errc::file_exists
            );
    }
    std::vector<std::uint32_t> a{};
    std::vector<std::uint32_t> b{};
    std::string str{};
    while (strm) {
        auto const c = char(strm.peek());
        if (std::isdigit(c)) {
            str += char(strm.get());
            continue;
        }
        if (c == ' ') {
            if (!str.empty()) {
                a.emplace_back(std::stoi(str));
                str.clear();
            }
        }
        if (c == '\n') {
            if (!str.empty()) {
                b.emplace_back(std::stoi(str));
                str.clear();
            }
        }
        [[discard]]strm.get();
    }
    fmt::print("a: {}, b: {}\n", a.size(), b.size());
    std::sort(std::begin(a), std::end(a));
    std::sort(std::begin(b), std::end(b));
    auto diff_view = std::views::zip(a, b) | std::views::transform([](auto const& p) {
        auto const [x, y] = p;
        return x > y ? x - y : y - x;
    });
    auto const sum = std::accumulate(std::begin(diff_view), std::end(diff_view), 0);
    fmt::print("Part A: {}\n", std::abs(sum));
    auto values = a | std::views::transform([&b](auto v) {
        return std::pair{v, b | std::views::filter([v](auto c) {
            return v == c; // Filter elements in `b` equal to `v`
        }) | std::ranges::to<std::vector>()};
    }) | std::ranges::to<std::vector>();
    auto const meow = std::accumulate(std::begin(values), std::end(values), 0, [](auto const acc, auto const& pair) {
        return acc + std::int32_t(pair.first * pair.second.size());
    });
    fmt::print("Part B: {}\n", meow);
    return {};
 }
--- a/sol/24/day02.cpp
+++ b/sol/24/day02.cpp
@@ -1,104 +0,0 @@
 #include <fstream>
 #include <vector>
 #include <algorithm>
 #include <ranges>
 #include <numeric>
 #include <cmath>
 #include <utility>
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 using namespace std::string_view_literals;
 using namespace aoc::types;
 auto part_a(std::vector<std::vector<i32>> const& reports) -> void {
    auto const diffvec = reports | std::views::transform([](auto const& levels) {
        return levels | std::views::adjacent_transform<2>([](auto const& a, auto const& b) {
                            return b - a;
                        }) | std::ranges::to<std::vector>();
    }) | std::ranges::to<std::vector>();
    auto answer = diffvec | std::views::filter([](auto const& levels) {
        auto const n = std::ranges::all_of(levels, [](auto v) { return v < 0; });
        auto const p = std::ranges::all_of(levels, [](auto v) { return v > 0; });
        auto const c = std::ranges::all_of(levels, [](auto v) { return std::abs(v) > 0 && std::abs(v) <= 3; });
        return (n || p) && c;
    });
    auto const sum = std::ranges::distance(answer);
    fmt::print("Part A: {}\n", sum);
 }
 auto part_b(std::vector<std::vector<i32>> const& reports) -> void {
    auto const diffvec = reports | std::views::transform([](auto const& levels) {
        return levels | std::views::adjacent_transform<2>([](auto const& a, auto const& b) {
                            return b - a;
                        }) | std::ranges::to<std::vector>();
    }) | std::ranges::to<std::vector>();
    auto const test_rule = [](std::vector<i32> const& levels) {
        auto const n = std::ranges::all_of(levels, [](auto v) { return v < 0; });
        auto const p = std::ranges::all_of(levels, [](auto v) { return v > 0; });
        auto const c = std::ranges::all_of(levels, [](auto v) { return std::abs(v) > 0 && std::abs(v) <= 3; });
        return (n || p) && c;
    };
    auto nochange = diffvec | std::views::filter(test_rule);
    auto unmet = std::views::zip(reports, diffvec) | std::views::filter([](auto const& vecs) {
        auto const& [levels, diffs] = vecs;
        auto const n = std::ranges::all_of(diffs, [](auto v) { return v < 0; });
        auto const p = std::ranges::all_of(diffs, [](auto v) { return v > 0; });
        auto const c = std::ranges::all_of(diffs, [](auto v) { return std::abs(v) > 0 && std::abs(v) <= 3; });
        return !(n || p) || !c;
    }) | std::views::transform([](auto const& vecs) {
        auto const& [levels, diffs] = vecs;
        return levels;
     });
    auto refit = unmet | std::views::filter([&test_rule](auto const& levels) {
        std::vector<i32> vec{};
        for (std::size_t i = 0; i < levels.size(); ++i) {
            vec = levels;
            vec.erase(std::begin(vec) + std::ptrdiff_t(i));
            vec = vec
                | std::views::adjacent_transform<2>([](auto const& a, auto const& b) { return b - a; })
                | std::ranges::to<std::vector>();
            if (test_rule(vec)) return true;
        }
        return false;
    });
    auto const first = std::ranges::distance(nochange);
    auto const second = std::ranges::distance(refit);
    fmt::print("Part B: {}\n", first + second);
 }
 auto aoc24::day02([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    auto txtres = aoc::read_text("./dat/24/re/02.txt");
    // auto txtres = aoc::read_text("./dat/24/ex/02.txt");
    if (!txtres) return std::unexpected(txtres.error());
    auto const txt = *txtres;
    auto const reports = txt | std::views::split("\n"sv)
                             | std::views::transform([](auto const& str) { return std::string_view(str); })
                             | std::views::filter([](auto const& str) { return !str.empty(); })
                             | std::views::transform([](auto const& str) {
                                return str | std::views::split(" "sv)
                                           | std::views::filter([](auto str) { return !str.empty(); })
                                           | std::views::transform([](auto const& num_str) {
                                                 return std::stoi(std::string(std::begin(num_str), std::end(num_str)));
                                             })
                                           | std::ranges::to<std::vector>();
                             }) | std::ranges::to<std::vector>();
    part_a(reports);
    part_b(reports);
    return {};
 }
--- a/sol/24/day03.cpp
+++ b/sol/24/day03.cpp
@@ -1,445 +0,0 @@
 #include <fstream>
 #include <expected>
 #include <string>
 #include <ranges>
 #include <numeric>
 #include <vector>
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 #include "ctre.hpp"
 namespace npr {
 #define ENUMERATOR_AOC_TOKENS                               \
        ENUMERATOR_AOC_TOKEN(mul            , operator_  )  \
        ENUMERATOR_AOC_TOKEN(invalid        , invalid    )  \
        ENUMERATOR_AOC_TOKEN(numeric_literal, number     )  \
        ENUMERATOR_AOC_TOKEN(newline        , punctuation)  \
        ENUMERATOR_AOC_TOKEN(paren_open     , punctuation)  \
        ENUMERATOR_AOC_TOKEN(paren_close    , punctuation)  \
        ENUMERATOR_AOC_TOKEN(comma          , punctuation)  \
        ENUMERATOR_AOC_TOKEN(identifier     , identifier )
 #define ENUMERATOR_AOC_CATEGORIES                           \
        ENUMERATOR_AOC_CATEGORY(operator_)                  \
        ENUMERATOR_AOC_CATEGORY(invalid)                    \
        ENUMERATOR_AOC_CATEGORY(number)                     \
        ENUMERATOR_AOC_CATEGORY(punctuation)                \
        ENUMERATOR_AOC_CATEGORY(identifier)
 #define ENUMERATOR_AOC_NODE_TYPES                           \
        ENUMERATOR_AOC_NODE_TYPE(numeric_literal)           \
        ENUMERATOR_AOC_NODE_TYPE(call_expression)           \
        ENUMERATOR_AOC_NODE_TYPE(binary_expression)
 enum class token_type : std::uint32_t {
 #define ENUMERATOR_AOC_TOKEN(type, category) type,
    ENUMERATOR_AOC_TOKENS
 #undef  ENUMERATOR_AOC_TOKEN
    _count
 };
 enum class token_category : std::uint32_t {
 #define ENUMERATOR_AOC_CATEGORY(type) type,
    ENUMERATOR_AOC_CATEGORIES
 #undef ENUMERATOR_AOC_CATEGORY
     _count
 };
 enum class node_type : std::uint32_t {
 #define ENUMERATOR_AOC_NODE_TYPE(type) type,
    ENUMERATOR_AOC_NODE_TYPES
 #undef ENUMERATOR_AOC_NODE_TYPE
     _count
 };
 auto token_type_str(token_type type) -> char const* {
    switch (type) {
        using enum token_type;
 #define ENUMERATOR_AOC_TOKEN(type, category) case type: return #type;
    ENUMERATOR_AOC_TOKENS
 #undef ENUMERATOR_AOC_TOKEN
        default: return "invalid";
    }
 }
 auto token_type_category(token_type type) -> token_category {
    switch (type) {
        using enum token_category;
 #define ENUMERATOR_AOC_TOKEN(type, category) case token_type::type: return category;
    ENUMERATOR_AOC_TOKENS
 #undef  ENUMERATOR_AOC_TOKEN
        default: return token_category::invalid;
    }
 }
 auto node_type_str(node_type type) -> char const* {
    switch (type) {
        using enum node_type;
 #define ENUMERATOR_AOC_NODE_TYPE(type) case type: return #type;
    ENUMERATOR_AOC_NODE_TYPES
 #undef ENUMERATOR_AOC_NODE_TYPE
        default: return "invalid";
    }
 }
 class token {
 public:
    token(std::string const& str, token_type type, token_category category, std::size_t row, std::size_t col)
        : m_type(type)
        , m_category(category)
        , m_value(str)
        , m_row(row)
        , m_column(col) { }
    auto type() const -> token_type { return m_type; }
    auto category() const -> token_category { return m_category; }
    auto value() const -> std::string const& { return m_value; }
    auto row() const -> std::size_t { return m_row; }
    auto col() const -> std::size_t { return m_column; }
    auto str() const -> std::string {
        using namespace std::string_literals;
        std::string str{"token {"};
        str += " value: \""s + m_value + "\","s;
        str += " type: "s    + token_type_str(m_type) + ","s;
        str += " row: "s     + std::to_string(m_row)  + ","s;
        str += " col: "s     + std::to_string(m_column);
        str += " }";
        return str;
    }
 public:
    inline static auto is_identifier(std::string_view const& str) -> bool {
        return ctre::match<"^[a-z']+$">(str);
    }
    inline static auto is_numeric_literal(std::string_view const& str) -> bool {
        return ctre::match<"^[0-9]+$">(str);
    }
 private:
    token_type     m_type;
    token_category m_category;
    std::string    m_value;
    std::size_t    m_row;
    std::size_t    m_column;
 };
 enum class lexer_error {
    eof,
    unknown
 };
 class lexer {
 public:
    lexer(std::string const& source)
        : m_strm(source, std::ios::in | std::ios::binary)
        , m_line(1), m_col(1) {
    }
    auto tokenize() -> std::vector<token> {
        std::vector<token> tokens{};
        auto tk = next_token();
        while (tk) {
            tokens.emplace_back(std::move(tk.value()));
            tk = next_token();
        }
        return tokens;
    }
 private:
    auto next_token() -> std::optional<token> {
        if (!has_next()) return {};
        std::string str{};
        auto const col = m_col;
        if (peek() == '\n') {
            peek_consume();
            m_line = m_line + 1;
            str += "\\n";
            m_col = 1;
            auto const& type = token_type::invalid;
            return token(str, type, token_type_category(type), m_line, col);
        }
        // mul, do, don't identifier
        if (peek() == 'm' || peek() == 'd') {
            auto const is_valid_identifier_char = [](auto const c) {
                return (c >= 'a' && c <= 'z') || c == '\'';
            };
            while (is_valid_identifier_char(peek())) str += peek_consume();
            auto const check_type = [](auto const str) {
                if (!token::is_identifier(str)) return token_type::invalid;
                return token_type::identifier;
            };
            auto const& type = check_type(str);
            return token(str, type, token_type_category(type), m_line, col);
        }
        if (peek() == '(') {
            str += peek_consume();
            return token{
                str,
                token_type::paren_open,
                token_type_category(token_type::paren_open),
                m_line,
                col
            };
        }
        if (peek() == ')') {
            str += peek_consume();
            return token{
                str,
                token_type::paren_close,
                token_type_category(token_type::paren_close),
                m_line,
                col
            };
        }
        if (peek() == ',') {
            str += peek_consume();
            return token{
                str,
                token_type::comma,
                token_type_category(token_type::comma),
                m_line,
                col
            };
        }
        if (std::isdigit(peek())) {
            while(std::isdigit(peek())) str += peek_consume();
            auto const& type = token::is_numeric_literal(str) ? token_type::numeric_literal : token_type::invalid;
            return token(str, type, token_type_category(type), m_line, col);
        }
        if (!has_next()) return {};
        str += peek_consume();
        return token{
            str,
            token_type::invalid,
            token_type_category(token_type::invalid),
            m_line,
            col
        };
    }
    auto peek() -> char {
        return static_cast<char>(m_strm.peek());
    }
    auto peek_consume() -> char {
        ++m_col;
        return static_cast<char>(m_strm.get());
    }
    auto has_next() const -> bool {
        return !m_strm.eof() && m_strm.good();
    }
 private:
    std::fstream m_strm;
    std::size_t  m_line;
    std::size_t  m_col;
 };
 class node {
 public:
    node(node_type type,
         token const& token,
         std::vector<node> const& nodes = {})
        : m_type(type)
        , m_token(token)
        , m_nodes(nodes) { }
    auto type() const -> node_type { return m_type; }
    auto token() const -> npr::token const& { return m_token; }
    auto nodes() const -> std::vector<node> const& { return m_nodes; }
    auto value() const -> std::string const& { return m_token.value(); }
    auto add_node(npr::node const& node) -> void {
        m_nodes.push_back(node);
    }
    auto str() const -> std::string {
        using namespace std::string_literals;
        std::string str{node_type_str(m_type) + " {"s};
        str += " value: "s + m_token.value();
        switch (m_type) {
            case node_type::call_expression:
                str += call_expression_str();
                break;
            default: break;
        }
        str += " }";
        return str;
    }
 private:
    auto call_expression_str() const -> std::string {
        if (m_nodes.size() == 0) return "";
        using namespace std::string_literals;
        std::string str{", ["};
        for (std::size_t i = 0; i < m_nodes.size(); ++i) {
            str += " "s + std::to_string(i) + ": "s + m_nodes[i].str();
            if (i < m_nodes.size() - 1) str += ",";
        }
        str += " ]";
        return str;
    }
 private:
    node_type m_type;
    npr::token m_token;
    std::vector<node> m_nodes;
 };
 class parser {
 public:
    parser() : m_cursor(0), m_tokens() { }
    auto parse(std::vector<token> const& tokens) -> std::vector<node> {
        m_cursor = 0;
        m_tokens = tokens;
        std::vector<node> nodes{};
        do {
            auto n = parse_statement();
            if (n.has_value()) nodes.push_back(n.value());
        } while(has_next());
        return nodes;
    }
 private:
    auto parse_statement() -> std::optional<node> {
        auto const type = peek().type();
        switch (type) {
            case token_type::identifier: {
                if (!has_next()) return {};
                auto next = peek_next();
                if (next.type() == token_type::paren_open) {
                    return parse_call_expression();
                }
            }
            default:
                break;
        }
        consume();
        return {};
    }
    auto parse_call_expression() -> std::optional<node> {
        auto const& token_callee = peek();
        node callee{node_type::call_expression, token_callee};
        consume();
        return parse_args(callee);
    }
    auto parse_args(npr::node callee) -> std::optional<node> {
        if (peek().type() != token_type::paren_open) return {};
        consume();
        while (has_next()) {
            auto const& arg_token = peek();
            if (arg_token.type() == token_type::numeric_literal) {
                callee.add_node({node_type::numeric_literal, arg_token});
                consume();
                continue;
            }
            if (arg_token.type() == token_type::comma) {
                consume();
                continue;
            }
            if (arg_token.type() == token_type::paren_close) {
                consume();
                break;
            }
            return {};
        }
        return callee;
    }
 private:
    auto peek() const -> token const& {
        return m_tokens[m_cursor];
    }
    auto peek_next() const -> token const& {
        return m_tokens[m_cursor + 1];
    }
    auto consume() -> void {
        if (m_cursor >= m_tokens.size()) return;
        ++m_cursor;
    }
    auto has_next(std::size_t i = 0) const -> bool {
        return m_cursor + i < m_tokens.size();
    }
 private:
    std::size_t m_cursor;
    std::vector<token> m_tokens;
 };
 }
 auto aoc24::day03([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    npr::lexer lexer{"./dat/24/re/03.txt"};
    npr::parser parser{};
    auto const tokens = lexer.tokenize();
    auto const nodes = parser.parse(tokens);
    // for (auto const& token : tokens) {
    //     fmt::print("{}\n", token.str());
    // }
    //
    // for (auto const& node : nodes) {
    //     fmt::print("{}\n", node.str());
    // }
    auto opa = nodes | std::views::filter([](auto const& node) {
            return node.value() == "mul";
        }) | std::views::transform([](auto const& node) {
            auto const a = std::stoi(node.nodes()[0].value());
            auto const b = std::stoi(node.nodes()[1].value());
            return a * b;
        });
    auto const sum = std::accumulate(std::begin(opa), std::end(opa), 0);
    fmt::print("Part A: {}\n", sum);
    std::vector<npr::node> program{};
    bool is_do = true;
    for (auto const& node : nodes) {
        if (node.value() == "do") {
            is_do = true;
            continue;
        }
        if (node.value() == "don't") {
            is_do = false;
            continue;
        }
        if (is_do) program.push_back(node);
    }
    auto opb = program | std::views::filter([](auto const& node) {
            return node.value() == "mul";
        }) | std::views::transform([](auto const& node) {
            auto const a = std::stoi(node.nodes()[0].value());
            auto const b = std::stoi(node.nodes()[1].value());
            return a * b;
        });
    auto const sumb = std::accumulate(std::begin(opb), std::end(opb), 0);
    fmt::print("Part B: {}\n", sumb);
    return {};
 }
--- a/sol/24/day04.cpp
+++ b/sol/24/day04.cpp
@@ -1,161 +0,0 @@
 #include <fstream>
 #include <expected>
 #include <string>
 #include <ranges>
 #include <numeric>
 #include <vector>
 #include <span>
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 #include "ctre.hpp"
 namespace cms {
 using vecn = std::vector<std::uint8_t>;
 using matnxn = std::vector<vecn>;
 // template <typename T>
 // class mat {
 //     class vec {
 //     public:
 //         vec(std::span<T> const& data) : m_data(data) {}
 //
 //         auto operator[](std::size_t i) const -> T const& {
 //             return m_data[i];
 //         }
 //
 //     private:
 //         std::span<T> m_data;
 //     };
 //
 // public:
 //     mat() : m_data(), m_rows(0), m_cols(0) {}
 //
 //     auto insert(std::size_t i, std::size_t j, T const& value) -> void {
 //         if (i >= m_rows && j >= m_cols) {
 //             std::vector<T> tmp = m_data;
 //             m_data.resize(i * j);
 //         }
 //     }
 //
 //     auto operator[](std::size_t i) const -> mat::vec {
 //         return vec({m_data[i * m_cols], m_data[i * m_cols + m_cols]});
 //     }
 //
 // private:
 //     std::vector<T> m_data;
 //     std::size_t    m_rows;
 //     std::size_t    m_cols;
 // };
 // Permutations:
 std::vector<matnxn> xmas_patterns{
    {
        {'X', 'M', 'A', 'S'},
        {'X', 'M', 'A', 'S'},
        {'X', 'M', 'A', 'S'},
        {'X', 'M', 'A', 'S'},
    },
    {
        {'S', 'A', 'M', 'X'},
        {'S', 'A', 'M', 'X'},
        {'S', 'A', 'M', 'X'},
        {'S', 'A', 'M', 'X'},
    },
    {
        {'X', 'X', 'X', 'X'},
        {'M', 'M', 'M', 'M'},
        {'A', 'A', 'A', 'A'},
        {'S', 'S', 'S', 'S'},
    },
    {
        {'S', 'S', 'S', 'S'},
        {'A', 'A', 'A', 'A'},
        {'M', 'M', 'M', 'M'},
        {'X', 'X', 'X', 'X'},
    },
    {
        {'X',   0,   0,   0},
        {  0, 'M',   0,   0},
        {  0,   0, 'A',   0},
        {  0,   0,   0, 'S'},
    },
    {
        {'S',   0,   0,   0},
        {  0, 'A',   0,   0},
        {  0,   0, 'M',   0},
        {  0,   0,   0, 'X'},
    },
    {
        {  0,   0,   0, 'S'},
        {  0,   0, 'A',   0},
        {  0, 'M',   0,   0},
        {'X',   0,   0,   0},
    },
    {
        {  0,   0,   0, 'X'},
        {  0,   0, 'M',   0},
        {  0, 'A',   0,   0},
        {'S',   0,   0,   0},
    },
 };
 auto read_text_matnxn(std::string const& path) -> matnxn {
    std::ifstream strm{path};
    if (!strm.is_open())
        throw std::runtime_error(fmt::format("Failed to open file {}", path));
    matnxn text{};
    vecn cols{};
    while (!strm.eof()) {
        auto const c = static_cast<std::uint8_t>(strm.peek());
        if (c == '\n') {
            text.emplace_back(std::move(cols));
        } else {
            cols.push_back(c);
        }
        strm.get();
    }
    return text;
 }
 }
 auto aoc24::day04([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    auto source = cms::read_text_matnxn("./dat/24/ex/04.txt");
    cms::vecn hpat{'X', 'M', 'A', 'S'};
    // for (std::size_t i = 0; i < source.size(); ++i) {
    //     auto const& cols = source[i];
    //     for (std::size_t j = 0; j < cols.size(); ++j) {
    //         bool is_h_match = true;
    //         for (std::size_t x = 0; x < hpat.size(); ++i) {
    //             if (x + i >= cols.size()) {
    //                 is_h_match = false;
    //                 break;
    //             }
    //             if (hpat[x] != cols[x + i]) {
    //                 is_h_match = false;
    //                 break;
    //             }
    //         }
    //
    //         // for (auto const& pattern : cms::xmas_patterns) {
    //         //     // for (std::size_t y = 0; y < pattern.size(); ++y) {
    //         //     //     auto const& pcol = pattern[y];
    //         //     //     for (std::size_t x = 0; x < pcol.size(); ++x) {
    //         //     //         if (y + i >= source.size() || x + j >= cols.size())
    //         //     //             break;
    //         //     //
    //         //     //         if (
    //         //     //     }
    //         //     // }
    //         // }
    //     }
    //     fmt::print("\n");
    // }
    return {};
 }
--- a/sol/24/day05.cpp
+++ b/sol/24/day05.cpp
@@ -1,7 +0,0 @@
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 auto aoc24::day05([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    return aoc::make_error("not implemented", std::errc::not_supported);
 }
--- a/sol/24/day06.cpp
+++ b/sol/24/day06.cpp
@@ -1,7 +0,0 @@
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 auto aoc24::day06([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    return aoc::make_error("not implemented", std::errc::not_supported);
 }
--- a/sol/24/day07.cpp
+++ b/sol/24/day07.cpp
@@ -1,7 +0,0 @@
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 auto aoc24::day07([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    return aoc::make_error("not implemented", std::errc::not_supported);
 }
--- a/sol/24/day08.cpp
+++ b/sol/24/day08.cpp
@@ -1,7 +0,0 @@
 #include "aoc.hpp"
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 auto aoc24::day08([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
    return aoc::make_error("not implemented", std::errc::not_supported);
 }
Author	SHA1	Message	Date
mnerv	1079b2536c	2025 day06 p2	2025-12-14 22:04:04 +01:00
mnerv	8062f9a537	2025 day 05 p2	2025-12-14 20:43:34 +01:00
mnerv	ed04586b1d	2025 day 07 p1	2025-12-14 18:43:39 +01:00
mnerv	11ed18a199	2025 day 06 p1	2025-12-14 17:39:21 +01:00
mnerv	65f6175bc9	2025 day 05 p1	2025-12-14 14:37:38 +01:00
mnerv	60e78353d7	2025 day 4 p1	2025-12-14 12:43:52 +01:00
mnerv	b90bcb0c9d	2025 day 3 p1	2025-12-14 08:00:30 +01:00
Pratchaya Khansomboon	7fb1f4f778	2025 day 2 p1	2025-12-11 13:57:49 +01:00
Pratchaya Khansomboon	abecf6cfb7	Add function in cmake to create targets	2025-12-09 16:12:19 +01:00
mnerv	432a5b1f7c	force solution Change-Id: I1421c6279597b9cb040dfcafb6984a3730503d10	2025-12-09 10:36:14 +01:00
mnerv	14ec3ca2da	2025D01P1: done	2025-12-09 04:20:27 +01:00
Pratchaya Khansomboon	d106e7541d	Prepare day01 2025 Change-Id: Id3c46f5f552db5a0ba200dedc1ea4e4434932982	2025-12-08 11:43:38 +01:00
Pratchaya Khansomboon	49d82b8f90	prep for 2025	2025-12-03 16:26:25 +01:00
mnerv	c238e9b4fb	aoc: 2024 bk	2025-12-02 09:13:23 +01:00
Pratchaya Khansomboon	da8a4cc5de	aoc24: day17 cpu	2024-12-18 21:53:42 +01:00
Pratchaya Khansomboon	5810fe22e9	aoc24: day17 started	2024-12-17 18:01:49 +01:00
mnerv	5c7da45fe1	aoc24: day16 create graph	2024-12-16 21:17:17 +01:00
Pratchaya Khansomboon	9c840a7c8f	aoc24: add day16	2024-12-16 16:43:34 +01:00
mnerv	1108b8c65b	aoc24: day07a complete	2024-12-16 04:03:02 +01:00
mnerv	7ae660566e	aoc24: add day11	2024-12-11 08:08:46 +01:00
Pratchaya Khansomboon	521b3dc806	aoc24: add day10	2024-12-10 17:45:40 +01:00
Pratchaya Khansomboon	c175b4ebc4	aoc24: day05 filter invalid	2024-12-09 15:16:11 +01:00
mnerv	ec9028c5f5	aoc24: add day07-08	2024-12-09 02:15:47 +01:00
mnerv	aaff50eae9	aoc24: day05a add back	2024-12-09 01:30:49 +01:00
mnerv	57d9bdf0f3	aoc24: day06a complete	2024-12-09 01:27:55 +01:00
mnerv	a35123500e	aoc24: Add README.md	2024-12-09 00:12:55 +01:00
mnerv	5a02b90f85	aoc24: day04b complete	2024-12-08 23:58:15 +01:00
-4
-3
-5
-3
-9
-3
-6 4 2 1
-2 7 8 9
-7 6 2 1
-3 2 4 5
-6 4 4 1
-3 6 7 9
		`@@ -1 +0,0 @@`
			`xmul(2,4)%&mul[3,7]!@^do_not_mul(5,5)+mul(32,64]then(mul(11,8)mul(8,5))`
		`@@ -1 +0,0 @@`
			`xmul(2,4)&mul[3,7]!^don't()_mul(5,5)+mul(32,64](mul(11,8)undo()?mul(8,5))`