mnerv/aoc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: mnerv:day03
Branches Tags
mnerv:trunk mnerv:day05 mnerv:day03 mnerv:day02
..
compare: mnerv:a1d5d359f281cf0652c1c05b18c4767223524465
Branches Tags
mnerv:trunk mnerv:day05 mnerv:day03 mnerv:day02

3 Commits
day03 ... a1d5d359f2

Author SHA1 Message Date
mnerv
a1d5d359f2 aoc24: day02b complete 2024-12-08 22:35:49 +01:00
Pratchaya Khansomboon
5c692fe727 aoc24: day05a complete 2024-12-06 12:13:39 +01:00
Pratchaya Khansomboon
8df8cbb0e4 aoc24: day05a split sections 
rules and updates
 2024-12-05 16:38:03 +01:00
19 changed files with 2157 additions and 47 deletions
Expand all files Collapse all files

56
CMakeLists.txt
View File

@@ -76,7 +76,7 @@ if (NOT MSVC)
# fmt warnings # fmt warnings
"-Wno-unknown-attributes" "-Wno-unknown-attributes"
# ctre warning # ctre warning
# "-Wno-missing-template-arg-list-after-template-kw" "-Wno-missing-template-arg-list-after-template-kw"
) )
else() else()
set(BASE_OPTIONS set(BASE_OPTIONS
@@ -89,10 +89,37 @@ else()
endif() endif()
set(HEADERS set(HEADERS
aoc/aoc.hpp 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") set(SOURCES "aoc.cpp")
add_library(aoc OBJECT ${HEADERS} ${SOURCES}) add_executable(aoc ${HEADERS} ${SOURCES})
target_include_directories(aoc target_include_directories(aoc
PUBLIC PUBLIC
${PROJECT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}
@@ -107,26 +134,7 @@ target_compile_definitions(aoc
) )
target_link_libraries(aoc target_link_libraries(aoc
PUBLIC PUBLIC
fmt aoclib
utf8cpp aoc24
ctre
stb::stb
Threads::Threads
)
source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${HEADERS} ${SOURCES})
set(HEADERS "")
set(SOURCES sol/24/day03.cpp)
add_executable(app ${HEADERS} ${SOURCES})
target_include_directories(app PRIVATE ${PROJECT_SOURCE_DIR})
target_compile_features(app PRIVATE cxx_std_23)
target_compile_options(app PRIVATE ${BASE_OPTIONS})
target_compile_definitions(app PRIVATE ${BASE_DEFINITIONS})
target_link_libraries(app
PRIVATE
aoc
)
set_target_properties(app PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
) )
source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${HEADERS} ${SOURCES}) source_group(TREE "${CMAKE_CURRENT_LIST_DIR}" FILES ${HEADERS} ${SOURCES})

31
aoc.cpp
View File

@@ -1,12 +1,25 @@
#include "aoc/aoc.hpp" #include <span>
#include <vector>
#include <fstream>
#include <expected>
#include <system_error>
#include <ranges>
#include <string>
#include <algorithm>
#include <numeric>
#include "fmt/format.h" #include "fmt/format.h"
auto main([[maybe_unused]]int argc, [[maybe_unused]]char const* argv[]) -> int { #include "aoc/utils.hpp"
try { #include "sol/24/aoc.hpp"
aoc::entry({argv, std::next(argv, argc)});
} catch (std::exception const& e) { auto entry([[maybe_unused]]std::span<char const*> const& args) -> std::expected<void, aoc::error> {
fmt::print(stderr, "Error at entry: {}\n", e.what()); return aoc24::entry(args);
return 1; }
}
return 0; 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;
} }

11
aoc/aoc.hpp
View File

@@ -1,11 +0,0 @@
#ifndef AOC_AOC_HPP
#define AOC_AOC_HPP
#include <vector>
#include <string_view>
namespace aoc {
auto entry([[maybe_unused]]std::vector<std::string_view> const& args) -> void;
}
#endif // !AOC_AOC_HPP

89
aoc/utils.hpp Normal file
View File

@@ -0,0 +1,89 @@
#ifndef AOC_AOC_HPP
#define AOC_AOC_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 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;
// Aliases
namespace nums = std::numbers;
template <typename T>
using lim = std::numeric_limits<T>;
inline constexpr auto pi = std::numbers::pi;
template <typename T>
inline constexpr auto pi_v = std::numbers::pi_v<T>;
struct error {
std::string msg;
std::error_code err;
};
inline auto make_error(std::string const& str, std::errc ec) -> std::unexpected<error> {
return std::unexpected(error{str, std::make_error_code(ec)});
}
inline auto read_text(std::string const& path) -> std::expected<std::string, aoc::error> {
std::fstream strm(path, std::ios::in | std::ios::binary);
if (!strm.is_open())
return aoc::make_error(path, std::errc::no_such_file_or_directory);
return std::string{
std::istreambuf_iterator<c8>(strm),
std::istreambuf_iterator<c8>()
};
}
// ranges and view aliases
template <typename T>
using vec = std::vector<T>;
}
#endif // !AOC_AOC_HPP

10
dat/24/ex/04.txt Normal file
View File

@@ -0,0 +1,10 @@
MMMSXXMASM
MSAMXMSMSA
AMXSXMAAMM
MSAMASMSMX
XMASAMXAMM
XXAMMXXAMA
SMSMSASXSS
SAXAMASAAA
MAMMMXMMMM
MXMXAXMASX

28
dat/24/ex/05.txt Normal file
View File

@@ -0,0 +1,28 @@
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

140
dat/24/re/04.txt Normal file
View File

@@ -0,0 +1,140 @@
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

1371
dat/24/re/05.txt Normal file
View File

File diff suppressed because it is too large Load Diff

24
sol/24/CMakeLists.txt Normal file
View File

@@ -0,0 +1,24 @@
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})

34
sol/24/aoc.cpp Normal file
View File

@@ -0,0 +1,34 @@
#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 {};
}
}

40
sol/24/aoc.hpp Normal file
View File

@@ -0,0 +1,40 @@
#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

68
sol/24/day01.cpp
View File

@@ -0,0 +1,68 @@
#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 {};
}

104
sol/24/day02.cpp
View File

@@ -0,0 +1,104 @@
#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 {};
}

9
sol/24/day03.cpp
View File

@@ -3,8 +3,10 @@
#include <string> #include <string>
#include <ranges> #include <ranges>
#include <numeric> #include <numeric>
#include <vector>
#include "aoc/aoc.hpp" #include "aoc.hpp"
#include "aoc/utils.hpp"
#include "fmt/format.h" #include "fmt/format.h"
#include "ctre.hpp" #include "ctre.hpp"
@@ -157,8 +159,8 @@ private:
if (peek() == '\n') { if (peek() == '\n') {
peek_consume(); peek_consume();
m_line = m_line + 1; m_line = m_line + 1;
m_col = 1;
str += "\\n"; str += "\\n";
m_col = 1;
auto const& type = token_type::invalid; auto const& type = token_type::invalid;
return token(str, type, token_type_category(type), m_line, col); return token(str, type, token_type_category(type), m_line, col);
} }
@@ -387,7 +389,7 @@ private:
}; };
} }
auto aoc::entry([[maybe_unused]]std::vector<std::string_view> const& args) -> void { 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::lexer lexer{"./dat/24/re/03.txt"};
npr::parser parser{}; npr::parser parser{};
auto const tokens = lexer.tokenize(); auto const tokens = lexer.tokenize();
@@ -438,5 +440,6 @@ auto aoc::entry([[maybe_unused]]std::vector<std::string_view> const& args) -> vo
auto const sumb = std::accumulate(std::begin(opb), std::end(opb), 0); auto const sumb = std::accumulate(std::begin(opb), std::end(opb), 0);
fmt::print("Part B: {}\n", sumb); fmt::print("Part B: {}\n", sumb);
return {};
} }

161
sol/24/day04.cpp Normal file
View File

@@ -0,0 +1,161 @@
#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 {};
}

7
sol/24/day05.cpp Normal file
View File

@@ -0,0 +1,7 @@
#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);
}

7
sol/24/day06.cpp Normal file
View File

@@ -0,0 +1,7 @@
#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);
}

7
sol/24/day07.cpp Normal file
View File

@@ -0,0 +1,7 @@
#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);
}

7
sol/24/day08.cpp Normal file
View File

@@ -0,0 +1,7 @@
#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);
}