diff --git a/sol/24/aoc.cpp b/sol/24/aoc.cpp
index 5abaa2f..ad48766 100644
--- a/sol/24/aoc.cpp
+++ b/sol/24/aoc.cpp
@@ -1,5 +1,6 @@
 #include <span>
 #include <expected>
+#include <string>
 
 #include "aoc.hpp"
 #include "ctre.hpp"
@@ -11,7 +12,7 @@ auto entry([[maybe_unused]]std::span<char const*> const& args) -> std::expected<
     u32 day = 1;
     if (args.size() > 1) {
         if (ctre::match<"^[0-9]+$">(args[1]))
-            day = std::stoul(args[1]);
+            day = u32(std::stoul(args[1]));
         else
             fmt::print(stderr, "arg: {} is not a number\n", args[1]);
     }
diff --git a/sol/24/day05.cpp b/sol/24/day05.cpp
index fb30020..8858706 100644
--- a/sol/24/day05.cpp
+++ b/sol/24/day05.cpp
@@ -11,15 +11,111 @@
 #include "aoc/utils.hpp"
 #include "fmt/format.h"
 
-namespace vfp {
 using namespace aoc::types;
-using order_rule = std::vector<i32>;
+
+auto part_a(std::vector<std::vector<i32>> const& rules,
+            std::vector<std::vector<i32>> const& updates) -> void {
+    // std::ranges::for_each(order_rules, [](auto const& rule) {
+    //     std::ranges::for_each(rule, [](auto const& page) {
+    //         fmt::print("{} ", page);
+    //     });
+    //     fmt::print("\n");
+    // });
+    //
+    // std::ranges::for_each(updates, [](auto const& update) {
+    //     std::ranges::for_each(update, [](auto const& page) {
+    //         fmt::print("{}, ", page);
+    //     });
+    //     fmt::print("\n");
+    // });
+
+    auto valid_updates = updates | std::views::filter([&](auto const& pages) {
+        return std::ranges::all_of(rules, [&](auto const& rule) {
+            auto const a = std::ranges::find(pages, rule[0]);
+            auto const b = std::ranges::find(pages, rule[1]);
+            return a < b || a == std::end(pages) || b == std::end(pages) || a == b;
+        });
+    });
+
+    // std::ranges::for_each(valid_updates, [](auto const& update){
+    //     std::ranges::for_each(update, [](auto const& page) {
+    //         fmt::print("{}, ", page);
+    //     });
+    //     fmt::print("\n");
+    // });
+
+    auto mids = valid_updates | std::views::transform([](auto const& updates) {
+        return *std::ranges::next(std::begin(updates), updates.size() / 2);
+    });
+
+    // std::ranges::for_each(mids, [](auto const& mid) {
+    //     fmt::print("{}\n", mid);
+    // });
+
+    auto const sum = std::accumulate(std::begin(mids), std::end(mids), 0);
+    fmt::print("Part A: {}\n", sum);
+}
+
+auto part_b(std::vector<std::vector<i32>> const& rules,
+            std::vector<std::vector<i32>> const& updates) -> void {
+    auto valids = updates | std::views::filter([&](auto const& pages) {
+        return std::ranges::all_of(rules, [&](auto const& rule) {
+            auto const a = std::ranges::find(pages, rule[0]);
+            auto const b = std::ranges::find(pages, rule[1]);
+            return a < b || a == std::end(pages) || b == std::end(pages);
+        });
+    });
+
+    auto valids_mid = valids | std::views::transform([](auto const& updates) {
+        return *std::ranges::next(std::begin(updates), updates.size() / 2);
+    });
+
+    auto invalids = updates | std::views::filter([&](auto const& pages) {
+        return !std::ranges::all_of(rules, [&](auto const& rule) {
+            auto const a = std::ranges::find(pages, rule[0]);
+            auto const b = std::ranges::find(pages, rule[1]);
+            return a < b || a == std::end(pages) || b == std::end(pages);
+        });
+    });
+
+    auto invalid_rules = rules | std::views::filter([&](auto const& rule) {
+        return !std::ranges::all_of(invalids, [&](auto const& pages) {
+            auto const a = std::ranges::find(pages, rule[0]);
+            auto const b = std::ranges::find(pages, rule[1]);
+            return a < b || a == std::end(pages) || b == std::end(pages);
+        });
+    });
+
+    auto const a = std::accumulate(std::begin(valids_mid), std::end(valids_mid), 0);
+    (void)a;
+
+    // std::ranges::for_each(valids, [](auto const& update){
+    //     std::ranges::for_each(update, [](auto const& page) {
+    //         fmt::print("{}, ", page);
+    //     });
+    //     fmt::print("\n");
+    // });
+    // fmt::print("--------------------------------------------------------------------------------\n");
+
+    std::ranges::for_each(invalid_rules, [](auto const& rules){
+        std::ranges::for_each(rules, [](auto const& rule) {
+            fmt::print("{} ", rule);
+        });
+        fmt::print("\n");
+    });
+
+    std::ranges::for_each(invalids, [](auto const& update){
+        std::ranges::for_each(update, [](auto const& page) {
+            fmt::print("{}, ", page);
+        });
+        fmt::print("\n");
+    });
 }
 
 auto aoc24::day05([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
     using namespace std::string_view_literals;
-    // auto txtres = aoc::read_text("./dat/24/ex/05.txt");
-    auto txtres = aoc::read_text("./dat/24/re/05.txt");
+    auto txtres = aoc::read_text("./dat/24/ex/05.txt");
+    // auto txtres = aoc::read_text("./dat/24/re/05.txt");
     if (!txtres) return std::unexpected(txtres.error());
     auto const txt = *txtres;
 
@@ -59,44 +155,8 @@ auto aoc24::day05([[maybe_unused]]std::span<char const*> const& args) -> std::ex
                    }) | std::ranges::to<std::vector>();
     }) | std::ranges::to<std::vector>();
 
-    // std::ranges::for_each(order_rules, [](auto const& rule) {
-    //     std::ranges::for_each(rule, [](auto const& page) {
-    //         fmt::print("{} ", page);
-    //     });
-    //     fmt::print("\n");
-    // });
-    //
-    // std::ranges::for_each(updates, [](auto const& update) {
-    //     std::ranges::for_each(update, [](auto const& page) {
-    //         fmt::print("{}, ", page);
-    //     });
-    //     fmt::print("\n");
-    // });
+    part_a(order_rules, updates);
+    part_b(order_rules, updates);
 
-    auto valid_updates = updates | std::views::filter([&](auto const& pages) {
-        return std::ranges::all_of(order_rules, [&](auto const& rule) {
-            auto const a = std::ranges::find(pages, rule[0]);
-            auto const b = std::ranges::find(pages, rule[1]);
-            return a < b || a == std::end(pages) || b == std::end(pages) || a == b;
-        });
-    });
-
-    // std::ranges::for_each(valid_updates, [](auto const& update){
-    //     std::ranges::for_each(update, [](auto const& page) {
-    //         fmt::print("{}, ", page);
-    //     });
-    //     fmt::print("\n");
-    // });
-
-    auto mids = valid_updates | std::views::transform([](auto const& updates) {
-        return *std::ranges::next(std::begin(updates), updates.size() / 2);
-    });
-
-    // std::ranges::for_each(mids, [](auto const& mid) {
-    //     fmt::print("{}\n", mid);
-    // });
-
-    auto const sum = std::accumulate(std::begin(mids), std::end(mids), 0);
-    fmt::print("Part A: {}\n", sum);
     return {};
 }