day 5 part 1

day1.zig

@@ -41,26 +41,6 @@ pub fn main() !void {
     }
 }
 
-fn rangeConst(comptime n: usize) [n]usize {
-    var array: [n]usize = undefined;
-
-    for (0.., &array) |i, *elem| {
-        elem.* = i;
-    }
-
-    return array;
-}
-
-fn range(alloc: std.mem.Allocator, n: usize) ![]usize {
-    var array = try alloc.alloc(usize, n);
-
-    for (0..n) |i| {
-        array[i] = i;
-    }
-
-    return array;
-}
-
 fn argsort_cmp(comptime T: type, comptime lessThanFn: fn (ctx: void, lhs: T, rhs: T) bool) (fn ([]const T, usize, usize) bool) {
     return struct {
         fn cmp(array: []const T, left_idx: usize, right_idx: usize) bool {
@@ -94,8 +74,8 @@ fn part1(alloc: std.mem.Allocator, reader: anytype) !u64 {
 
     std.debug.assert(right_list.items.len == num_lines);
 
-    const left_idxs = try range(alloc, num_lines);
+    const left_idxs = try utils.range(alloc, num_lines);
-    const right_idxs = try range(alloc, num_lines);
+    const right_idxs = try utils.range(alloc, num_lines);
     defer alloc.free(left_idxs);
     defer alloc.free(right_idxs);
 

day3.zig

@@ -16,7 +16,7 @@ pub fn main() !void {
 
         const result = try part1(alloc, file_reader.reader());
 
-        try std.io.getStdOut().writer().print("Day 2, part 1: {}\n", .{result});
+        try std.io.getStdOut().writer().print("Day 3, part 1: {}\n", .{result});
     }
 
     {
@@ -25,7 +25,7 @@ pub fn main() !void {
 
         const result = try part2(alloc, file_reader.reader());
 
-        try std.io.getStdOut().writer().print("Day 2, part 2: {}\n", .{result});
+        try std.io.getStdOut().writer().print("Day 3, part 2: {}\n", .{result});
     }
 }
 

day4.zig

@@ -0,0 +1,236 @@
+const std = @import("std");
+
+const utils = @import("utils.zig");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const alloc = gpa.allocator();
+
+    const filename = "inputs/day4.txt";
+
+    {
+        const file_reader = try utils.FileReader.init(alloc, filename);
+        defer file_reader.deinit();
+
+        const result = try part1(alloc, file_reader.reader());
+
+        try std.io.getStdOut().writer().print("Day 4, part 1: {}\n", .{result});
+    }
+
+    {
+        const file_reader = try utils.FileReader.init(alloc, filename);
+        defer file_reader.deinit();
+
+        const result = try part2(alloc, file_reader.reader());
+
+        try std.io.getStdOut().writer().print("Day 4, part 2: {}\n", .{result});
+    }
+}
+
+fn check(grid: []const []const u8, needle: []const u8, i: usize, j: usize, i_step: usize, j_step: usize) bool {
+    var idx = i;
+    var jdx = j;
+
+    for (0..needle.len) |n| {
+        if (grid[idx][jdx] != needle[n]) {
+            return false;
+        }
+
+        idx +%= i_step;
+        jdx +%= j_step;
+    }
+
+    return true;
+}
+
+fn part1(alloc: std.mem.Allocator, reader: anytype) !u32 {
+    const input = try reader.readAllAlloc(alloc, std.math.maxInt(usize));
+    defer alloc.free(input);
+
+    // number of lines in number of newline + 1
+    // except if the last line is empty, then one less
+    var num_lines = std.mem.count(u8, input, "\n") + 1;
+    if (input[input.len - 1] == '\n') {
+        num_lines -= 1;
+    }
+
+    const grid = try alloc.alloc([]const u8, num_lines);
+    defer alloc.free(grid);
+
+    // var it = std.mem.splitScalar(u8, input, '\n');
+    var it = std.mem.tokenizeScalar(u8, input, '\n');
+
+    const line_length = it.peek().?.len;
+
+    for (grid) |*grid_line| {
+        const line = it.next().?;
+
+        std.debug.assert(line.len == line_length);
+
+        grid_line.* = line;
+    }
+
+    std.debug.assert(it.next() == null);
+
+    const xmas = "XMAS";
+    const samx = "SAMX";
+
+    var count: u32 = 0;
+
+    for (0..num_lines) |i| {
+        for (0..line_length - 3) |j| {
+            if (check(grid, xmas, i, j, 0, 1)) {
+                count += 1;
+            } else if (check(grid, samx, i, j, 0, 1)) {
+                count += 1;
+            }
+        }
+    }
+
+    for (0..line_length) |j| {
+        for (0..num_lines - 3) |i| {
+            if (check(grid, xmas, i, j, 1, 0)) {
+                count += 1;
+            } else if (check(grid, samx, i, j, 1, 0)) {
+                count += 1;
+            }
+        }
+    }
+
+    for (0..num_lines - 3) |i| {
+        for (0..line_length - 3) |j| {
+            if (check(grid, xmas, i, j, 1, 1)) {
+                count += 1;
+            } else if (check(grid, samx, i, j, 1, 1)) {
+                count += 1;
+            }
+
+            if (check(grid, xmas, i, j + 3, 1, std.math.maxInt(usize))) {
+                count += 1;
+            } else if (check(grid, samx, i, j + 3, 1, std.math.maxInt(usize))) {
+                count += 1;
+            }
+        }
+    }
+
+    return count;
+}
+
+fn part2(alloc: std.mem.Allocator, reader: anytype) !u32 {
+    const input = try reader.readAllAlloc(alloc, std.math.maxInt(usize));
+    defer alloc.free(input);
+
+    // number of lines in number of newline + 1
+    // except if the last line is empty, then one less
+    var num_lines = std.mem.count(u8, input, "\n") + 1;
+    if (input[input.len - 1] == '\n') {
+        num_lines -= 1;
+    }
+
+    const grid = try alloc.alloc([]const u8, num_lines);
+    defer alloc.free(grid);
+
+    // var it = std.mem.splitScalar(u8, input, '\n');
+    var it = std.mem.tokenizeScalar(u8, input, '\n');
+
+    const line_length = it.peek().?.len;
+
+    for (grid) |*grid_line| {
+        const line = it.next().?;
+
+        std.debug.assert(line.len == line_length);
+
+        grid_line.* = line;
+    }
+
+    std.debug.assert(it.next() == null);
+
+    const mas = "MAS";
+    const sam = "SAM";
+
+    var count: u32 = 0;
+
+    for (0..num_lines - 2) |i| {
+        for (0..line_length - 2) |j| {
+            if (check(grid, sam, i, j, 1, 1) or check(grid, mas, i, j, 1, 1)) {
+                if (check(grid, sam, i, j + 2, 1, std.math.maxInt(usize)) or check(grid, mas, i, j + 2, 1, std.math.maxInt(usize))) {
+                    count += 1;
+                }
+            }
+        }
+    }
+
+    return count;
+}
+
+test "part1 example" {
+    const alloc = std.testing.allocator;
+
+    const example =
+        \\MMMSXXMASM
+        \\MSAMXMSMSA
+        \\AMXSXMAAMM
+        \\MSAMASMSMX
+        \\XMASAMXAMM
+        \\XXAMMXXAMA
+        \\SMSMSASXSS
+        \\SAXAMASAAA
+        \\MAMMMXMMMM
+        \\MXMXAXMASX
+    ;
+
+    var stream = std.io.fixedBufferStream(example);
+
+    const result = try part1(alloc, stream.reader());
+
+    try std.testing.expect(result == 18);
+}
+
+test "part1 input" {
+    const alloc = std.testing.allocator;
+
+    const filename = "inputs/day4.txt";
+
+    const file_reader = try utils.FileReader.init(alloc, filename);
+    defer file_reader.deinit();
+
+    const result = try part1(alloc, file_reader.reader());
+
+    try std.testing.expect(result == 2593);
+}
+
+test "part2 example" {
+    const alloc = std.testing.allocator;
+
+    const example =
+        \\MMMSXXMASM
+        \\MSAMXMSMSA
+        \\AMXSXMAAMM
+        \\MSAMASMSMX
+        \\XMASAMXAMM
+        \\XXAMMXXAMA
+        \\SMSMSASXSS
+        \\SAXAMASAAA
+        \\MAMMMXMMMM
+        \\MXMXAXMASX
+    ;
+
+    var stream = std.io.fixedBufferStream(example);
+
+    const result = try part2(alloc, stream.reader());
+
+    try std.testing.expect(result == 9);
+}
+
+test "part2 input" {
+    const alloc = std.testing.allocator;
+
+    const filename = "inputs/day4.txt";
+
+    const file_reader = try utils.FileReader.init(alloc, filename);
+    defer file_reader.deinit();
+
+    const result = try part2(alloc, file_reader.reader());
+
+    try std.testing.expect(result == 1950);
+}

day5.zig

@@ -0,0 +1,364 @@
+const std = @import("std");
+
+const utils = @import("utils.zig");
+
+const List = std.DoublyLinkedList(u8);
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const alloc = gpa.allocator();
+
+    const filename = "inputs/day5.txt";
+
+    {
+        const file_reader = try utils.FileReader.init(alloc, filename);
+        defer file_reader.deinit();
+
+        const result = try part1(alloc, file_reader.reader());
+
+        try std.io.getStdOut().writer().print("Day 5, part 1: {}\n", .{result});
+    }
+
+    {
+        const file_reader = try utils.FileReader.init(alloc, filename);
+        defer file_reader.deinit();
+
+        const result = try part2(alloc, file_reader.reader());
+
+        try std.io.getStdOut().writer().print("Day 5, part 2: {}\n", .{result});
+    }
+}
+
+const Edge = struct { from: u8, to: u8 };
+
+fn isCorrectlyOrdered(pages: []const u8, edges: std.AutoHashMap(Edge, void)) bool {
+    for (0..pages.len) |i| {
+        for (i + 1..pages.len) |j| {
+            const edge = Edge{ .from = pages[j], .to = pages[i] };
+
+            if (edges.contains(edge)) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+fn findIndex(slice: []const u8, value: u8) ?usize {
+    for (0.., slice) |i, x| {
+        if (x == value) {
+            return i;
+        }
+    }
+
+    return null;
+}
+
+fn findNode(list: List, value: u8) ?*List.Node {
+    var node_ptr_maybe = list.first;
+
+    while (node_ptr_maybe != null) : (node_ptr_maybe = node_ptr_maybe.?.next) {
+        const node_ptr = node_ptr_maybe.?;
+
+        if (node_ptr.*.data == value) {
+            return node_ptr;
+        }
+    }
+
+    return null;
+}
+
+fn topo_sort(elems: []u8, incoming_edges: std.AutoHashMap(u8, List), outgoing_edges: std.AutoHashMap(u8, List)) void {
+    // this function works in-place by splitting elems into an first, sorted part and a later,
+    // unsorted part
+
+    var _incoming_edges = incoming_edges;
+    var _outgoing_edges = outgoing_edges;
+
+    // this index marks the first element of the unsorted part of elems
+    var next_unsorted_idx: usize = 0;
+
+    // step 1: find all nodes with no incoming edges, move them to the sorted part of the list
+    for (next_unsorted_idx..elems.len) |i| {
+        if (_incoming_edges.get(elems[i]) == null) {
+            // if elems[i] has no incoming edges, move it to the end of the sorted list
+            std.mem.swap(u8, &elems[next_unsorted_idx], &elems[i]);
+
+            // advance end of sorted list by one
+            next_unsorted_idx += 1;
+        }
+    }
+
+    // step 2: progressively iterate over sorted section, removing outgoing edges and adding nodes
+    // with no incoming edges to the end of the sorted section
+    for (elems) |value| {
+        // if value has outgoing edges...
+        if (_outgoing_edges.get(value)) |outgoing_list| {
+            // iterate over outgoing edges
+            var node_ptr_maybe = outgoing_list.first;
+            while (node_ptr_maybe != null) : (node_ptr_maybe = node_ptr_maybe.?.next) {
+                const node_ptr = node_ptr_maybe.?;
+
+                const to_value = node_ptr.*.data;
+
+                if (_incoming_edges.getPtr(to_value)) |incoming_list_ptr| {
+                    // cannot fail: we know the edge (value, to_value) existts
+                    const node = findNode(incoming_list_ptr.*, value).?;
+
+                    // remove edge
+                    incoming_list_ptr.remove(node);
+
+                    if (incoming_list_ptr.len == 0) {
+                        _ = _incoming_edges.remove(to_value);
+
+                        // cannot fail: to_elem must be in unsorted section of elems // [next_unsorted_idx..]
+                        const to_value_index = next_unsorted_idx + findIndex(elems[next_unsorted_idx..], to_value).?;
+
+                        // std.debug.print("{}    {}\n\n", .{ next_unsorted_idx, to_value_index });
+
+                        std.mem.swap(u8, &elems[next_unsorted_idx], &elems[to_value_index]);
+                        next_unsorted_idx += 1;
+                    }
+                } else {
+                    // we know we have an edge (value, to_value), can't fail
+                    unreachable;
+                }
+            }
+
+            // remove all outgoing edges at once
+            _ = _outgoing_edges.remove(value);
+        }
+    }
+
+    std.debug.assert(_incoming_edges.count() == 0);
+    std.debug.assert(_outgoing_edges.count() == 0);
+}
+
+fn part1(alloc: std.mem.Allocator, reader: anytype) !u64 {
+    var line_reader = utils.lineReader(alloc, reader);
+    defer line_reader.deinit();
+
+    // var elems_set = std.AutoHashMap(u8, void).init(alloc);
+    // defer elems_set.deinit();
+
+    // var edge_arena = std.heap.ArenaAllocator.init(alloc);
+    // defer edge_arena.deinit();
+
+    var edges = std.AutoHashMap(Edge, void).init(alloc);
+    defer edges.deinit();
+
+    // var outgoing_edges = std.AutoHashMap(u8, List).init(edge_arena.allocator());
+    // var incoming_edges = std.AutoHashMap(u8, List).init(edge_arena.allocator());
+
+    while (try line_reader.next()) |line| {
+        if (line.len == 0) {
+            break;
+        }
+
+        var it = utils.numberParserWithDelimiter(u8, line, '|');
+
+        const from = (try it.next()).?;
+        const to = (try it.next()).?;
+
+        std.debug.assert((try it.next()) == null);
+
+        // try elems_set.put(from, {});
+        // try elems_set.put(to, {});
+
+        // try edges.append(.{ .from = from, .to = to });
+        try edges.put(.{ .from = from, .to = to }, {});
+
+        // _ = try outgoing_edges.getOrPutValue(from, List{});
+
+        // if (outgoing_edges.getPtr(from)) |list| {
+        //     const node_ptr = try edge_arena.allocator().create(List.Node);
+        //     node_ptr.*.data = to;
+
+        //     list.*.prepend(node_ptr);
+        // } else {
+        //     unreachable;
+        // }
+
+        // _ = try incoming_edges.getOrPutValue(to, List{});
+
+        // if (incoming_edges.getPtr(to)) |list| {
+        //     const node_ptr = try edge_arena.allocator().create(List.Node);
+        //     node_ptr.*.data = from;
+
+        //     list.*.prepend(node_ptr);
+        // } else {
+        //     unreachable;
+        // }
+    }
+
+    // const elems = blk: {
+    //     const elems = try alloc.alloc(u8, elems_set.count());
+
+    //     var it = elems_set.iterator();
+
+    //     for (elems) |*p| {
+    //         p.* = it.next().?.key_ptr.*;
+    //     }
+
+    //     std.debug.assert(it.next() == null);
+
+    //     break :blk elems;
+    // };
+    // defer alloc.free(elems);
+
+    // topo_sort(elems, incoming_edges, outgoing_edges);
+
+    // std.debug.print("sorted elems:  ", .{});
+    // utils.printSlice(u8, elems);
+    // std.debug.print("\n", .{});
+
+    // for (edges.items) |edge| {
+    //     std.debug.print("from: {}    to: {}\n", .{ edge.from, edge.to });
+
+    //     const from_idx = findIndex(elems, edge.from).?;
+    //     const to_idx = findIndex(elems, edge.to).?;
+
+    //     std.debug.print("from_idx: {}    to_idx: {}\n", .{ from_idx, to_idx });
+
+    //     std.debug.assert(from_idx < to_idx);
+    // }
+
+    var update = std.ArrayList(u8).init(alloc);
+    defer update.deinit();
+
+    var sum_middle_pages: u64 = 0;
+
+    while (try line_reader.next()) |line| {
+        update.clearRetainingCapacity();
+
+        var it = utils.numberParserWithDelimiter(u8, line, ',');
+
+        while (try it.next()) |n| {
+            try update.append(n);
+        }
+
+        std.debug.assert(update.items.len % 2 == 1);
+
+        // var update_idx: usize = 0;
+
+        // for (elems) |n| {
+        //     if (update.items[update_idx] == n) {
+        //         update_idx += 1;
+        //     }
+
+        //     if (update_idx == update.items.len) {
+        //         const middle_idx = update.items.len / 2;
+
+        //         sum_middle_pages += update.items[middle_idx];
+
+        //         break;
+        //     }
+        // }
+
+        if (isCorrectlyOrdered(update.items, edges)) {
+            const middle_idx = update.items.len / 2;
+
+            sum_middle_pages += update.items[middle_idx];
+        }
+    }
+
+    return sum_middle_pages;
+}
+
+fn part2(alloc: std.mem.Allocator, reader: anytype) !u32 {
+    _ = alloc;
+    _ = reader;
+
+    return 0;
+}
+
+test "part1 example" {
+    const alloc = std.testing.allocator;
+
+    const example =
+        \\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
+    ;
+
+    var stream = std.io.fixedBufferStream(example);
+
+    const result = try part1(alloc, stream.reader());
+
+    try std.testing.expect(result == 143);
+}
+
+test "part1 input" {
+    const alloc = std.testing.allocator;
+
+    const filename = "inputs/day5.txt";
+
+    const file_reader = try utils.FileReader.init(alloc, filename);
+    defer file_reader.deinit();
+
+    const result = try part1(alloc, file_reader.reader());
+
+    try std.testing.expect(result == 5129);
+}
+
+// test "part2 example" {
+//     const alloc = std.testing.allocator;
+
+//     const example =
+//         \\MMMSXXMASM
+//         \\MSAMXMSMSA
+//         \\AMXSXMAAMM
+//         \\MSAMASMSMX
+//         \\XMASAMXAMM
+//         \\XXAMMXXAMA
+//         \\SMSMSASXSS
+//         \\SAXAMASAAA
+//         \\MAMMMXMMMM
+//         \\MXMXAXMASX
+//     ;
+
+//     var stream = std.io.fixedBufferStream(example);
+
+//     const result = try part2(alloc, stream.reader());
+
+//     try std.testing.expect(result == 9);
+// }
+
+// test "part2 input" {
+//     const alloc = std.testing.allocator;
+
+//     const filename = "inputs/day5.txt";
+
+//     const file_reader = try utils.FileReader.init(alloc, filename);
+//     defer file_reader.deinit();
+
+//     const result = try part2(alloc, file_reader.reader());
+
+//     try std.testing.expect(result == 1950);
+// }

inputs/day4.txt

@@ -0,0 +1,140 @@
+SXXSAMSSMMSMMSXXXXMMXMMMMSMMMSSSXSAMXMXSXMASXMSMXSMMXSMSXMMASXMASMSSMMXSMSSSSSSXSXMAMXAMXSMSXSXXMMMMMXXMSSMMSXSASASMMSXMASXSSSSSMXMASMSMXAMX
+SAXMASAXMASAAXMASXSSXSAAASASAAXMASMXXSASAMXAAAAMMSAMAMXSAAXASAMSXXAAXMMSAMAAAASAMXXMMSXSASXSAMXMSAAAMMMMASXXAAXASXSAAXAXAAAXAAXAMSMMMAAAASMM
+MAMSXMAXMMXMMXAXXXAAASMMMXAMMSMMMMXMXMASXMASMSMSASAMMMASAMMXSAMAXMSSMSAMAMMMMMMXMSMSMAAMASXMAMAASXSXSMAMAMMMMSMAMAXMMSAMMMMMMMSMMAAAMSMSMAAS
+AAMMMSMSMSSMSSSMSMMMMMMMXMAMXAXAAXAMXMAMAAAXXXAMASXMAMXSXMSASAMXMXXAAMXMAMXXXXMMXAAAMMMMSMXXAMXXSXMAAMSMAMAXAAMXMSMMXXAXAAXMXXSXSSSMMAMXMSSM
+MASXAAAAXXAAAAAAXAMAMXSAXMSMSMXSSSXXAMASXMXMMMXMXMXSXXAMAASAMXMMMSMMSMSMSXXMXSAAMMMMXAASXASXMSXXSAMSMMXSXSASXSSMAMAMAXSMMAMMXMMAXAXXXAMAXMAX
+MAXMMMSMSSMMMSMMMSMASXMXSXAMASAAMXMSMSXSXMAXAXXSXMXMAMMSMMMMMASAAAAMXASAMXSMAMMSXMSSSXSAMXMASAMXMAMXXMMMXMASXAAMAMASMSMMXSXMAMMXMMMMSSMMSSSM
+ASMSMXXXMAMAAXXMAXXAXXAAMMMSAMXSMAAAAAXMMXMSSXMXMMAMAAXAMMAMMASMSMSMMAMAMXMMASXMAAAAAMXMMASMMXMAXAMXMASMXMXMMMXSAXMAMSXAAXASMXSAAXXXAXAXAAMX
+MMAXMASXXAMMMSMMSSMMSSMMSAXMAXSAMASMSMAXAAMAMASAXSASMXMAMSASMMSXMMMXMAMAMAMMXSASMMMMMXMAMAMMASMSSSSMAXXMAXAXXMAXAXSSMSMMXSAMSAXSSMMMMSMMMSMX
+XMXMXMASMMMAAXXMASAAAXAASXSSMMSAMXAXAXMMSXSAXXMAXMXMXAMAMSAMMASXMASAMASASMSMAMAMXASXSSSMMSSMXSAAAXMXXMASMSASAMMSSMAAAXAMAMAMMMMMXMAXXAXAXAXS
+MSXMAMAMMXMMMSAMASMMSSMMSAXXAAMAMMSSMASAMXMMMSMMMSSSSMSAMMAMXMSAMASASASASAAMMMSMSXSAAAMXSMAMMMXMSMSSMAMSMAASMAMAXMMMMMSMASAMASXMASASXMSSSXSS
+MMXSAMXMSXSAAXXMAXXAXAXMMXMSMMSAMMXAXAMXMAAAASAMAXAAAMSAMSAMXXSXMXSAMAMMMMSMSAMXSXMMMMMMXXAMMSAMXMASAAASXMXMMXMAMMXSAMAMAMASASMSAMMSAXXAAXAX
+XXXMMSAAAAMMMSASMSMMSSSXSAXAAASMAXMAMSSSMSSXMSAMSSMMMMSMMMSMMMMASAMXMAMXAAXXMASAMMMXMMAMSSMSXAASAMMSSMXMAXSAMXMASMAXAMSSSSXMMSAMXSSXMXMASMMS
+MAXAAMMMMMMAMAAAMAAXAAXASMSSMMMMSSMAMMAXAAAMMMMMAAAAXXMAMAAXAAXAMASMSMSMMSSXSAMXXAMAMSASAASAASMMMSXMXMASXMMAMAXAAMMXSMAAMXXMAMXMMXMAMXMAXAAA
+ASMMSXXAAMSSSMMMSMSMMSMMMXAXAMXAAXMAMMAMXMSMMAAMMSMMMXSAMMSSSSSXSSMAMAAXAMXMSMMMSSMMMAXMMSMMMMAXAMMMASAXAASAMSMSSXSAMMMMMXXSAMASXMMXMSMMSSSS
+SXAXXASXXXAAXMMXSMAMSAMXSMMSSMMMSSMMSMMMXXMASXMXXAMXMMMSSXAAAAXAMXMAMMMMSSXXXMAMSXAXSASMXAAXSMXMASASXMXSSMMMXXAMXAMXMAMSXXXSASXSMMMSMSAMXAAX
+ASAMXXMASMMSMASAXSXMXASAXAXAXAXSXAMAMAASXXSAMXSAMXSASAAAXMMMMSMSMXXMMXAAMMMMMSSSMSSMAAMXSXSMASASXSXMAXAMAASMSMMMMMMSSMSSMMMSXMAXAAMAASXMMMMM
+AMXXXXMXMXMMAMMXXAMXSAMXSSMSSMMXMXSSSSMSAAMAMASMSMSASMMMXMXXXAAAXSMSMSMXSAXXAAMAAXXXMSSXSAMXAMMSAMXSMMSSSMSAXAAAAXXAAXAXAAXSASXXXMSMMMMXAAAA
+MASMMXSASMSMSMMMMMXXAXXAXXAXXMAXSAMMAMAMXMMMMXXAMAMAMXMAXSASAMMMMSAAAMMASMMMMSSMMMMXXAMASMMMSSMXAXAAXXXAMAMAMSSSMXMSSMMSMMSXAXSXSAMXMAASMSSS
+MASAAXSAMAMXAAASAMSAMXMMMMSMSMSXMASMAMSMMXMSMMMSMSSSSSXAASASAXXMSMAMSMMASAMXAMXMAASXSMMAMXSAAAASMMMSSMMAMXMAMXAXASMMMAXSXMSMSMAMSAMXXMXAAMAM
+MAMMAXMAMSMXSSMSASAMSASAAMAXAAMMSAMXMAMAMXAAAAMAAXSAXAMMXMAMMMSMAMXSXMMASAMSMSAXSMSAMXMAXXMASMMMXAXAXASAMMMSSSMMMMAAMMMXAMXAAMSMSMMXAMAMSMSM
+MMSMSMSAMMSMAAAXXXAMSASMSSMSMSMASXMASASAMXSSSMMMXMMXMMXSAMXMMAAMAMMMAXMASAMAASAXMAMXMASXSASMAMAXMMMMMMAMXSAAAXAMXASMMASMSMSSMSAAXMXAMXAXXAXA
+SMXAAXMAMAAMXMXMXXXMMMMXMAXMAMMXMAXAMXMXMMMXXMMSMSMAAXSSXAAXMSSSMSXSAMMMSXMMMMXMXASXMXAASAMAAAMMSXAXXAXXAMMSMSMMAMMXXMAAAAAAXSXSMSMSMMMSMMMX
+AAMSMSSMMSSSXAMSMSMSMSSMMSAMXMASMSMXSMSMSAMXMMXAAASASMAMMMMSMAMAAMASASXMXAMXSMMSSXMXMMSAMXMSSXXAASXSSMMMASAMXMXAAXMASXMSMMMSMSAMAXXAAAAXAAMM
+MXMXAXAAXXAMMSMAAAAAASMAAXAMXSAXAXAMMAAASASXXASMSMMSAMASAASAMXSSMMASXMASXSAAXMAMMAXAXMAASMXAAAMSMMMXAAXSMMASASMSMMSAXAXMXSXMAMAMMMMSXMMXXMSM
+XSAMXSSMMMAMAXSMSMMMXMXXSSSMAMASMSSSSMSXSMMMMMSAAAMXXSASXMSASAAAAMXSASASMAMSSMSSSMSMSMMXMMMMMMMAAAMXMMMXASXMASXAMXMASMMXASAMSSSMSSXXXSSSMAAM
+MMASAMXMAMAMXMMMAXXXSMSMAAAMMSXMXAAMAAXAXAAXAAXMSSMMMMASXXMAMXXMMMASMMASAMXMAAAXAMAAAASMMXMAAXMSSMMAAAMSMMXMMMMMSSXAAMMMXSAMAAAAAXXXASAAMSMS
+ASAMAMMXMMASXMASASMXMAAMMMMXXXAMXMSMMMMASXSSMSMXMAMAASMSXSMXSASXXMASAMXMMXXMMMXMXSMMMSAAASMSXSAMXAMSSMMAXAXAAAAXAMMSMMAMXSMMMSMMMSMMMMSMMMXM
+MMXSSMSASXXMASAMAMMAMAMXSAMXMSMMAMMAMXMXMAAXAMMSSMSSMSAXAXXXMAXXAMXXAMMSXMXXSXSSXXMXXMMMMMAAAXXMMSMXAMSAXXSSMSXMAMXAMMSSMXXMXXXAXMASAAMMASAX
+MMAXMAMASAMXASAMXMSAMASMSASXAAAMAXMAMMMAMMMMXMAXAAMMMMAMSMMMMAMMSMMMSMAMAMMMSAAXMAMMXMMMSMXMASXXSMMSAMMMXXAAMAMSSMMASAXAMXSAXSSSSMMSMXXSASMS
+SMMSMSMAMAMMXSAMMMSASASASAMMSMSSXSSSMMMAMAAMAMXSMMMAAXAAAAAAXMMXXAXAXMXSASMAMMMMMAMAASAAXXMMSMXMXAAXAMAAMMMMAXMAMMMMMXXAMAMMAXAMXMAMMAXMMMXS
+AAAXAAMXXMMMXSXMAXSAMXMMMAMAAXAMAMMAASMMSSXSMMXMAMSSSXMSSXSMSMSMSMMMSAASAMMMMXXAMSSSXSMXSAXSAMASAMMSSMMMSAAMMMMMXXAMMMSMMXSXSMMMAMASMXMASXAX
+SMMSMMMMXSXSASMMSAMXMMMXSXMSSSXMMMSSMMAMAXXAXXAMXMAAXXXAXXXAAAAXAMXXMMMMASMASMMMAXAMXMAASAMSASMSASAMAAAAMMMXXAXXASMSMAAAMXSXXMAMAXMXXAMAMMXM
+XMASAMXSSMAMXSAMXXMAMAMASAXAMXMASMMMMSXMASMSMSMSAMXSXXMASMMSMSMSMSAXSSXSXMMASAASMMXMXMXXMAMSAMASXMASXMMSSXSXSSSMASAAMSSSMAMMMSMSSSSMMSMAMXMA
+XMAXAMXXAMAMXMMMSMXAXXSASXMAXSAMXAAXMXAMXMAXAAAMXSAXMSMMMAXMMXMAXXXXMAAXXAMXSMMAXMAMXMMXSSMMAMXMXSXMASMXAAMXMMXXAMXAMXAAMASAXAMAMAAAAXSSMAAS
+SSMXSMMXSMASASASAMSSSMMXSXSMMSSMSSMMSMMMMMSMSMSMAMAXAXAMSXMXMASMSMSMMMMMSXMASXSMSXMMASAXXAASAMXMMMAXMMAXMXMAXMAMXMXMMMMMSASMSXSAMSMMMMAXMXSX
+MAAAXAMAASMSXXXMAXAXMASMSAAMAXAXAAMAAAAXXAAAAAXMSMMMSSMMSMMASAXAAAAXXAAXAXMAMASXSASAAMSSSSMMXSAXMSSMXSMSXXSASMASAMMXXSSMMXSAAASMXMAASMSMSMXM
+XMMMSAMSMMXMMMSSMMSSMMSXMMMMXSMMSSMSSSMMMMSSMMMXAAAAAAAASASXMAXSMSMXMXSSMMXSMMMASAMMXSXMAXSAAXMSXAAAAAXAXAMASMXMXXSAXMASMSMMMXMSASXMMAAAAMMM
+XSAMMXMAAMSXAAAAAAXAMMSAMXXXAAXXAAMXAMASXMAXAXXXSSMSSXMMSAMXMAMMAXMXSAXXXSAMASMAMMMXXSAMXMMMSSSSMSSMMMMMMSMAMXXMAXAMMSMMXXAAMSAMXSAAMSMSMSAS
+MSASASMSSMASMSSSMMMAMASMMMSAMMSMSMMMASAMXMASMMSXMAMMMASAMMMMMASMAMAAMMMMSMASMMMMSMXMAXMMAASAAXAMAAMAMXXXAAMAXXAMSXMMAXXMXSSMSMAMASMSXMAXASAS
+ASXMMMAAAMXMMMMMASXXMXSXSASAMXXAMAXSMMXSXMXMAAXXMASXMAMAXXAAMXXMMMMMXXAXXXAMXAAXAMSSSMMSMSAMSSMMMMSSMMSMSSSMSSMAMAXMXMAAAMXMAMXMASXAAMMMAMAM
+MSMSAMMMMXAMSAASMMAASMSAMXXAMXMAMXXSXMMMAMMXMSMMSASAMXSXMSSSSSSXAAMMASMSXMSSSSMSASAAAXMAMXMSMXXXXXXXAAXAXAAXAAMAMMMSMSMSAXAMAMXMASAMXMAMXMSS
+AXAMMSSSXSMXXMXSAMSMMAMMMXMSMSMSAMXSASAMAMAXSAXMMAXMMXMAMAAAAAXMSMSAMMAMXMAAMAASXMASMSXMXSXMAMMSMMMSMMXMMMMMSXMASAAXAAAAASMSMXAMMXXXAXMMAMXM
+MMSMXAAMMXMASXMSXMAAMSMMXMAMAXSMMXAMXMSSXSMXSAMXAAMSAMXSMSSMMMMXXASMXSSSSMAXMMMMXXAMXXASASAMAMAAASAAAXMMSSXMXASASMSMMXSMXMAAXSXSSXMSXXSASXSS
+XAAMMMMMAXMASAASMSSSMMMSASMMAMMMSMMXSAMXMAXASAMMMSSXASAMXAAAXXXXMAMXAAAAMMMSXXMAMMMSXSMMASAMAMSXSAASMMSAAMAXMAMXMXAXSXMXXMMAMXAMAAMAAAXAMASX
+SSSXAXAMSMMAMMMMAMAMASASAXAXAXAAXAMAMMAAAXMXMAMXAMMMMMMSMMSMMSMXMMMXMMMMMAAMASMASAASXSAMXSAMXXMMMXAMMAMMXSAMXSSMMSMMSAMAXXMASMMMXMMMSMMXMXMM
+MAXMSSXXAAMMXXXMAMXMAMXMMSSMMMMMSAMAMASMSSMSSSMMMSAASAMAXMXXMASXSAMXSAMXMMXSAMMAMMSMAMXMMMMMMAAASAMXXMSXAMMSAMAAXXXASXMASXSASXSSXAXXAXAXXAXA
+MXMMMMMSSSXMAXMSAXXMASXMAMAAXXAMSXMXMMXAMXAMAAXASMMMSASASXMASAXXMASASASXXAAMAMMSSMAMAMAMMMAAXSMMXAXXSSSXAMAMASMMMAMMSMMMMXMASAAASMMMSXSAMXMS
+SMXAAAMAMAMAMSASASXMASXMAMSSMXMAMXXMASMSMMMMSMMMSAMXXXMASAXXMASASMMMMXMASMSMSMXMAXSSMSMSAMXSMMAMSSMXSAMXMMMSAMXMAMMAXAAAXXMSMMMMAXSAMXMASAAM
+MMSSSSMAXXMAXMXMXAMXASXSXXAAXMSSSMMSMMAAMXMAXXMAMAMASXMMMXMXXMAXXMASXAXXXAMAAXXSXMMMMAMXASXMASXMAMMSMMMSMAXXMAXXXXMXSSMSAAXAAAXXSAMXXASASMSS
+XAAXMAXMSXMXSSSSXSAXASAAXMSMMXAMAXAMXMAMMAMMSASASAMAXSAAAXMXSSMMMSASXMMAMAMSMMMMXAMXSASMXMXXAMXMASMAAAAAMSMXSMSMSASAMXAMXSMMSMSMMSSMSMMASAAM
+MMSSSSMXAASAMAAAAMSMMMAMXMAXXMASMMXSAMAXXASXSAMAXAMXMSMMMASAAAAAAMMSAMAMMMMAXAAMMXMASASMASXMSMMSAMXSSMSXXXMMXAAAMXMMSMMMAMAXAXMXAAXMAXMAMMMS
+AMAMAMMMSXMAMMMMMMXSMASXMSSMXSMMASXSASMSMMSAMAMXMSXSAMXASXMMXSMMMMAMAMSXAASXSSSXAAAMMMMMSMAMMAXMXSAXXAXMMSAMMMMSMMMAAAAMMSMMXSMMMMSXMXMMMMAA
+SSMMAMXAXASAMAMXAXMAXXXAMXXAASXSMMASAMASXAMAMAAMXMASMXSXSMASAXXMASXMMMXMSXSAAAAMMMSXAXXXASXMSMMAAMMMMMMSAAAMXXAXXAMSSSMSMAMSMMMAAXSAXXASMMMM
+XMASMMMMSASASASXMSMSAMSMMAMMMMASXMAMXMAMASMSMMSMAXXXXAMMMMAMXSASASMASASAMAMMMMMASAMMMMMSXXMMAAMMMSAAAXAMMMMMXMSSXMXXMAMXMAXAAASASAMAMSAMAAMX
+SSMMSAAMMMMASASXSAAAMAAXMASMMMMMAMXMXMXSXXAAAXAMMMSAMMSAMMXSXSAMXSXMMAMXMAMAXXXSMAMMSAAXAMXSSSMXXSXSSMMXXAMXMAXAASXMSSMMSSSSSMSMXAMSMSASXMSS
+MAMASMMMASMMMAMXAMSMXSMXAXSAAAMMXMAMXXXAAMSMMXSASXAXMAXASXXXAMMMMXAXMXMXXASXMAMMSSMASMSMXAXAAAMXMXMAXASASMMSASMSMAAAAMAXAAXAAMXMMMMMASAMMMAM
+SMMMXAXSASAMMMMXMAMXMAMXSXMXSMSAASXMMMSMMMXAXXXMXASMSXSMMMMMSMAAXMMMMMMSSXSAAAMAAMXXMAXAXSMMSMMMAAAXSMMMXSASMXAXXSMMMXMMMSMSXMASAMAXXMMMMMXS
+MXASMSMMASMMAAXMXSSMSASMXAAAXMMMXMAXMAMAMASMMMSMXXMAXAMAAXAAAXMXSASXXAAMMXSXSSSMASAMMXMXMXAXXMMMSMSXAAAMXMXMAMAMAXMASAXMAMMXASXAXSXSXMSAMSMS
+XSXSAMXXAMASMSXMMXAASASAMMMMXMAMMXSMMSSSMMSAXAAMMMMXMXSMMMMSSSMXXMAXMMSMSAMXXXAMAXAXSMSXSSXMSAMAAXXASMMSAMSMMMAMXMMAMMMSXMAXAMXMMAXSAMMAMAAS
+MMMMMMMSMSXMAMASMMMMMXMMMXSASMSXMAAAXAMAAASMMSMXAXMAXMMXMAXAAAMMSSMXSAMXMAXXSSXMAMSMAAMXXAMXXAMSMMAXMAMXAMSAMSXXMSMSSSXMASMSASAXXMXMASXSMMSM
+MAAAXAAMXSASXMAMAAAXMXAXXXSASAAAMSSMMSSSMMSXAAASXMSAXASAMXMASMMAXXXAMASXSAMSAMXMSXMAMXMMSMMSMXMAAMXAMXMSMMSAMXMMAMAMAXXMAMXAASMSMXXSAMAAAXAX
+SSMSMMXSAMASAMSSSMMASXSSMAMXMMMMMXAXXMAMAMMXSMAAAXMAASAMXXXMMXMSSXMMSXMAMAXSAMSMMAMXXSAAMAAXMASXMMMMSMMASASAMAMAXMAMMMSMXSAMMMMMASAMXSSSMMMM
+XMAMXAAMMMAMXXAAAMSMXAAXMAMMXMXASXMMMSMSAMMMXMMMSMMSMMAXMMMMMXMAAXSXSXMXSMMSAMXSMMMMMMMSSMMXSASAAXSAAMSAMXSASXMAXXXSXAXMAXAXXAASMMMMAMMMMAAA
+ASASASMSXMMSSMMSMMASMMMMSSXSAMXMAAXMAXXSMSXAXXMAXAAXAXMMMXAAMMMMSMMASXMXMXMSAMXAXXAAAXAMXMMXMSSXMXMMSXMASASMMXMSSXAMMSMSSSMMSMXSAAAMAMAXXMSS
+XMASAXAXMSAAAAMMASASXAMASAASMSMXSSMMXSAMASXXMAMXMSMSMMSSMSSXSAMXMAMAMSMAMAMXAMXMMSSSSSXXMSSMSAMASMMAXAMAMMSXASMAMMAMXMMAMAMAAMAMMMMSXSMMXMAA
+MMXMAMMMAMMSSMMSAMASXMXMMMMMMAMAXAXAAMAMAMMMMXMAXXXMAXXAAAASXMSASAMMSAXASASMMXAXMAMXAXMASAAXMASAMAMASAMXMASMXMMAXAMXXAMASMMMSXMSMSXSAAAASMSM
+ASMMMSAAXMXAAAXMMMXMXSAMXXMAXAXMXMMXXMSMXXAAMAMSSMASXMSMMMSMSASMSAMXSAXMSASASMMXMXSMSMSXMASMSMMMSSMASAMXMAMSASMMSSSSSMSAMMAAMAMAXSAMSMMMXAAX
+MAAAASASMMMMSSMMSSMSASASXMSXSAXSAXAMXMMASASXMAMAAMAMAAXAAXXXXMXAXXMXXMAMMMSAMXMAMXSMMASMMAAMXAXASAMXMAMXMAXAMXAAXAAAXMMMSSMMSAMSMMAMXMXSMAMM
+MSMMXSXMMXAXAXAAAASMASXMAXAAMAMXAMXSAAMAMAMXSSSSSMSSSSMSMXMAAXMMMAXMASXXAMSAMXXASMSAMAMAMAXMXMMMXAMAXSMSMMXAXSMMMSMMMSXXXAAASXSAASMMXSAAXMAS
+MMAMASMAMSSMMXMMXXMMMMMSMMAMSSSMMMASMSMAMMMXXAAAMAXAAXXXMXMSSMAMSMMMAMASMMMXMSSMSASMMMSXMXASASXSSXMMSAAXAASXMMAMAMAXXAMMSMMMMXXXXMMSAMXXAMXX
+ASAMMXMAAXAMXASMSMSMMMMAXXAXXAXMAMMSAXXAXAMMMMMMMMMMMMASXMMAAXSAAAAMAMXMXAXAXXAXMXMXAXMAMSMXASAMXXMXAMMMMMXMASXMASAMXMXAXASMSSMMSAAMXSAMSXSM
+MSXMMXSMSSSMSASAAAAXAXXMXXMSMMMSAXAMAMSMMMMAAMXXAAAAASMASAMSSMASXXSSXMAASMSSSSSMMAMSMSMXXASMAMMMXMASMXSXXAXXMMMXXSXMXXMXSAMAAXMASMMSMXMXMASA
+XMAMXMXAMAMAMAMXMSMSMSMMSSMAAAASMSMSAAAAASMSSSMSSSSSXXXAASMAXMAXXAMAMSSMAXAXAAAAXAXAXAAMMAMXMASXMMAXXMXMAMMAASMSMMAMMSAMXXMMMMMMXXMAXMXMMAMM
+MMAMAMMMMMMXMXMAXXXAAAAAAAXSXMXSAAXSMMMMMSAAAAXMAMXXMMSSMMMXXSAMMMMAMAMXXMMMMMMSSSSSSMMMMSMMAMMAAASXMAAMAMSSMMAAMSSMAMSSXMMXXSAXSASMXSAXMAMX
+XXAXAMAAAMAMXMMXSXMMMMSMSSMMASMMXSXXMSMSAMMMXMMMAMSMAMXAXMMSMMAAXMSSMXSXXASAXXAXXXAAXASAAXAMXSSSMMAAASAMXXAMXMMMMAAMMSAMASMAMXAMAMXMASXXSAXX
+XSMSSSSSSSMMSAXAAAXSAAAXXMAXSAXSAMXXAAAMSSXSAXXSAMASXXSXMXAXASXMXXAAMAAMSMSMSMSSMMMMMXAMMSXMXMXAAXSSMMAMXMASMMASMMSAMMAMAAMASMMMMMXMXMAMSMSM
+MAAXMAXAAXAASMMMSXMXMSSSMMSXAMXMASXMSMSMAMASMXMAASMXXAMXMMMSXMAXMMMSMSMMAAXAAAXAXSASXAMMMXXSASMSMMMXMMAMXMXMAXAXAXXAMXXMXXMASASXXSMMMMSAXMAM
+MMSMMSMMMMMMSAMAMAMSMMXAXAMSMXMMAMXXAMAAAMXMXMSSMMXSSMMAMAMXAXMMAAMAAMASMSMSMSMSMMASMSXXAAXXAMAXASXAMSMSSSSSSMXSSMSSMXSMMSMMSMMMMAAXXAXMASMS
+XAAAAXAAXXMASAMASXMAAXMXMAMAXAMMAMXXASXSXSXSAXMAMXXXAAXXXAMSXMSASXSAXSMMAXAAXMXXXMAMMMMMMMMSXMMSAMSMMAAMAAAAMMMMAASXMASAASAMXXAAXMSMMXSXAXSA
+MSSMMSMMMMSMSAMASASMSMSAMXMMSASXSSMSXMXMAXAXMSSSMSMSSMMSSMXSMASAMXAXMMMMXMSMSMXMSMMSAXXAAXMASMXMMMMSSXSMMMMMXXAMMMMAMASMMSXMAXXSSXMAMAMMMMAM
+XAXXMAXAAAAASAMXSMSAMXSASASXMASAAAAXAMAMMMSMSAMXAAAAAAAAAXASAMMXMASXSXAXSAMXSMAMAASMASMSSSMAXXAMXAXAMAMXSXSXXMSMMAMXMASAXXMSMSMAMASAMASASXMX
+MAMXSSSMSSSMMAMAXXMAXXMASASXMMMMSMMMSMASAAXSMSSMSMSMSMMXSMXXMXAAMMAAMSSMSXSAMSMSMSXMMMXXAXMXMSMMSXMAMXMASAMAMAAASMSSXAMXMAXXAAMSMASASXMASAXS
+XSMAMXXAXXXASXMASXXMMMXMMAMAMAAXMASAASMSMXMAMXXAMXMXMXMXMASMMSAMXMMMMAXXSAMXAMXXXMXSAMSMMXAMXXAAAMMSMMMAMAMAMSSXMSAAMMSSSXMMSMSAMASMMMMAMMMS
+AAMXMAMSMSSMMSXMAXAXMAMXMAMXSMMMSAMSXMMMXSXMMXMMMXSASAMXSASAAMXMXSAAMMMXMXMMMMXMAMAXXMXAMMMXASMMMSAMASMAMXSXXXMASMSMMAAASAMXAXXMMXSAAMMASXAM
+XMSAMXMAAMMMAMMSASMSMSMXSAXMAMSAMXXXMSXSASMMSSMASXMASAMMMAMMMSMSAXSSSXMSSSMSAAASMMMSMMSSMASMMXSMAMXSXMMMMXAMMSMMXMASMMMSMSAMXSSXMAXXMMSXSMMX
+MMMMMMSMMMAMMSAMXSXXAAAXXASMAMMAMMMAMMAMASXAAASAMMMAMXMSMMMSXAAMAMXMXAAXAAASMSMSAASAMAAASMMAAAMMAMXXAMASMMMMAAAMAMSXMAXXMASMAAMAMXSMSASASMSM
+MAAAAMAMXSXXAMMXMXAMMMSSMMMMAMSAMAMAMMAMAMMMXMMXXAMASAXMASAASMSMMMMASMSMSMXMXXXSMMSASXSMMXSSMMSAXXXSXMAXAAAMSSSMSXMASMMMXMMMXMSXMAAAMMMAMASX
+XSSSMSMXXXAMSSSMSMSXSAAXAAXXAXXMSASASXAMMSSSMMSMSSSMMMXSAMSMMXXXXAMXMAXAMMMSASAMXXXMMAMXMAMAMAXMMSAMXXASMMMXMAXXXAMAMAASMMMMSAMMMMMXSXMSMMMS
+XXAMAMXSSMMMAAAAAAAAMMMSSMSSXXAXSXSASXXSAAAMAASAMXAXSXAMXMMXMASXSMSXMMMSMAAMXXAASAMXMXMASAMXMXSAAMAMMXMAXAMMMMMMSSMSMSMSAXAAMMMAXXSAAMMMAAAS
+XMAMMMXAAASMMSMMMMMSMMXMAXXAASXMSASMMAMAMMSMMMSSMSMMAMXSMSAMXAXMASXMSAAAMMSSXSSMSAMASXSASASMMXMMXSASXMSASAMAAAAXAAAMMMAXMMMSSMSSXSMMMMAXMMMM
+AMAMXSXMSMMMMMMXXXAAMMASAMMMMMXAXXSAMMAXSXMAMAMAXMAMMSMMMXMSMMMSMMSASMSMMXAMAAMASMMMSAMASXMAMXXAAXXSAAAAXXXSSSSMXMMMASAMXMAAAXMAXXAXAXXSMSSM
+XSAMXMAMAAAAAXSAMXSAXSASAMXAAXMSMMXAMXSXMMSAMASMMSXMXAXMAMMAMAAXXAMMMXXASXAMMMMMMAAAMMMMMMSASXMSSSMMMMMMMSXMAMMMSMXMXMAAAMMMXMXMASMMMSAAXAAX
+MAMSXXSAMSSSXSAMXXXMAMXSAMSSXXAAASMMMAMAXAMAXMXMAAASXSXSMXXASMSSMMSAMXMAMMMMAAAAMXMSMMAAAASMSAAAAAXAAMXMAXAMXMAAAAAMSSMSASMSSSSMMASAAMXMMSSM
+XMAXXXMAXAMXMAXMXAMMAMXSAMMMMXSSMMAXMAXSMSSSMSSSMSSMAMASXSMAMAAXAASASAMAMAMXSSSMXSXXASXXMXSXSMMMMMSXMXXMMSSMMSMXSSMMAAAMAAAAXAXAAAMMMXSSMMXM
+XXMMMMSAMMSSSSMMXAXMAMXXXMSASMAMASAMSSXXAAAAAMAAAXAMXMXMAMMXMMMSMMSASAXAXASAXMMAASXSAMAASAMXMASXAASMSMSAAAXXASAAMAMMMMMMXMMSMMSSMSSXSAMASAXS
+MXXAAAXMSXMMAXAXSMMXSSSXMAMAMMXMASAMAXAMXMXMAMXMMMXSXMXMSMAXSSXXAAMXMMSSSMMMSAMMMMAAXMSMMASXSAMAMMMAAAMMMMSASMMMMAMXSMAMXMAXAXAXAAMAMASAMSMA
+AMSSSXMASXMMMMXXMASMMAXXSMMSMMSMXMAMAMSMSSSXXSAASXXMASAAMMXSAAXSMMMMXXAMXMAMMAMAAMAMSAMXSXMXMMMAXSMSMSMXMASXMXSXMXMAXAAAAMASXMMSMASMSXMASAMM
+MAMAMXSXMASAXSAMSAMMMXMMSAAXAMAMXSSMASAAMAAAAXXSMAXXSAMXSAMMMMXSAAMSMMASAMAXMASMSMSXSAMXXSMXSXSMSAAMAMXXMASAMAMMSSMASXMSMMMSMAXXXAMXAMXSAMXX
+ASMSMAMASAMMMAMAMASMSMSAMMMSXSASMXMASMMSMMMMMSSMXXXSMMMXMAMAXXXSMMXAASASASASMAXMAXMAMAMMMSXXSAMXAMMMAMMMMXSXMASAAAMAXMAXXAMXMXMASXMSAMXMAXMS
+XMAXMASMMMSAMASMSAMXAAMXMAMXMXASXXAMXXAMMSAMXMAAXSMMAAXXSSMSMMMMMXSSXMASAMASMXMAMAXAMAMAAXMXMXMAXMASASAAXXMASASMSMMSSSSSSXSAMXMXAAXMAXSMAMAM
+SMAMSXSAAASASXSAMAMSMSMMSMSASMSMXMASAMXMASMSAMMMMAAXSMSMMMAAMAAAXXXMAMXMXMAMAMMMSAMSSMSMXSASAXSASMXSASXSSXSXMMSAAAXAMXAXAMMMMAMSMMMSXMAXAXAX
+SMSMSASMMMSAMXMXMAMMSMXAAMSASXAAASAMXXAMAMAXMXSAMSXMAMAAAMSMMSMMSAAMSSXMAXXXAAMAMAXMAXXAXXMAMXMASAASXMAMAMXXXAMMMMMASMMMXMAXXAXAAXAMXAMSSSMS
+SAXASAMXXMMAMSMMSASXAMSMSXMXMMMSMSASASMSSMMMSASAXAASXSSSMMMMXXMMMMMMAXAXASMSMSMXSMMSMMMSMMXMMMMXMMAMXMAMMAXMMMSMAASXMAAAMSMXSSSSSMASMSXAXAAS
+MAMXMAMXMASAAAAMSASMAMAAMXMAAAXMMSMMASAAMMAMMASMMXXMAAMXMSMMAMAAAAMMSXMMMXAAAAXMAMMAMMAMXXAAAXSAMXMMXSXSXSXAAAAMMMXAMSMSMASXAXMAXMAMMMMMSMMM
+MMMSSMMAAMSXSSMMMAXXASMXMAXXSMMSASAMAMMMMMAXSXMASMMMSMMAMASMASXSSXSAMAMXSMSMMMSSSXSASMSMAXSSMMSMXAAXMSASAMXSMSSSMMSAMAMAMAMMAMXASMXSAXAAAAMA
+MAAXMASXSXMXMAXAXXMSMMXASXXMAAAMMSAMSSMAAMMMMASXSASAAASXSAMMASAXAXMASMMASXXXSXAMXASMMMAMAMXAXXMASXSMMMAMAMAMMMMXAMMMSXSAMMMSMMMMMAMSMSMXSSMA
+SMSSSXMAXAMXMAXXSSMXSSMXMAASMMMMXSXMMAXSSSMAXMMAMAMXSMMXMASMMMXMMMXXMMMXMAMXMMSSMXMAXSAMXMMASMAXXMAAAMAMXMMSASAMMMAAXAMMXSAAMMAAAAAXMAMXMAMM
+MAMXXXMXSMMSMSSMAAXAMXXASXMMAAXXMMMXSAMXAAXMSSMMMSMXMAMXXAXASXXMAAXMAXMAMSMSAMMMAMMXMSASASMAMMMMSMSXSSMSAMMSXMASXSMSXMMSAMMSMSXMSXSMSASMXMMS
+MSMMSMSAAAAXAAAMSMMSSMSXXAAXSSXSAAAAMXMMSMMXAMAAXAAASAMXAXMAMXASMXXMAMMAXAAMXSASASXMASAMASMMMMSAMAAAXAMSXSASXSAMXSAMXAAMASAXXSMMMAMAMMSMXSAA
+XXAXMAMXMMMXMMSMAXAXAXMASMMMXAAMMMMXSXMAMMAMMSSMSXMMSSSXMMMSSMMMXAXMMSSMSMSMXSASASXXAMAMAMAMAAMAMXMSMAMMASASAMAMMMAMSMMXMMASASXAMAMSMMMXXMAS
+MSMMMAMMSSMMSAMMMMXSXXMAMAAXMMMMSSSMXASASMAMMAMXAASXXXXAMXSAAAMAMSMMSAXAAMMMAMMMAMAMMSSMASAMMXSMMMXMMSMMAMXMAMMSSMMMAASMXMXMAMMXXXMAXAAMMSAM
+AXAASXSXAAAAMMMAXMMMMSAMXSMXMASMAAXAXASAMXAXMASAMMAAMMSMMXMSSMMASMAMMMMSMSAMXXAMAMMAAAXXMMMMSAAAAXXMAXAMMXASMSXAXMAXXMMAASMMSMAXMSSXSXSAXMMS
+SXSMSAXMSMMMSSMMSXSAAXMSAMXMXMXMMSMSMAMAMSSSSMSAXXMSAAAAXMMAMXSXSMSMAMXMXMMSAXSSMSSMMSSSMXMAXMSSMSSMSSSMMSMSAMMSMAXSSSMXMMAAXMSAXAAMAAMXXMMM
+XXXASMXMXAMAMMAMAAXXMXAMXSMSAMXSXAAXAXMXXAMMAASMMSXMASXSMASASXSAMAMSXMAMXMXMXXMAMAXAXAAAMSMSXXXAXAAAAAAAASXMAMXXAMSXAAAASMMMMAMMMXSAMXMXSXAM
+SMMAMXSMASMAXSAMMSMSMSAMASASASASAMAMSSMMMSSMMMMMAAAMAAXAMMMASXMAMXMAXMASASAAXXMAMMSMMMMMMSAAASMMMXMMMMMMMSASXMASAMXMMMXMXAXSMXXXXAMXXMASMXMS
+SAMXMASXAXSXMSXSXMASAAASASXMAMASMMAAXAASAMAMXSAMMSXMXSSMMAMXMASAMMMAXSAMASMSMMSAXAAAXXMMAMMMMMAXAMXMSXMAMMMMAMMSMMXAXAXSSMMSAMXXXXXAXXMAXSMS
+XMMXMASMXMAMXSXMAMAMXSMMASXSXMXMXSXSSSMMXSASASAMAAAXAMAXXXXXXXSASAXMMAAMAMXAAXXAMSMMMMXMAMAMASMMXSAAAASXSMXSAMXMXMXSMMMMAAAXASAMSMMMMMXMXSAM
+MXSAMXSAXMASAMMSSMXAAMAMXMAAMMXMAMMXMXAMXXXMASXMXSMMXSXMASMXSASMMMAMXSMMSSSMSMMSMMASAMXSMSMSMMAAASMMMXMAAMMMMXAMXSAMXMASXMMSXMAMAAASASXSAMAM
+AASASMMXMMMMASAAXMSMXSAMAMXMAMAMAXMAMMAMXMXMAMXSAAMSAMXSXSAXSASAMXSAMXMXXAMXXXXMAMXMASAMAAXAMSMMMSAMXMMSMMAXAMAXMMMSASXSAXMSXSXMSMMSASAMXSAM
+SXSAMXMXXAAMXSMSSMAAXSMSMXAXMSSSMXXAMSAAASAMMSXMXSAXSAMXAMXMMAMXSMMXXMAMXAMMMMMMAMASMMASAXSAMAASASMMSXAMASMSSSMSAAXXMSMXMSMXAMAXMAMMMMAMASAS
+XMMMMASMSSMSASAMAMMSMMXMASMSMAAAAAXSMSXSMSXSXMASXMMSXXMMXMMXMAMXSAMASXMAMMMXAXASASAXASAMMMAXMMSMASXAMMXSAMXSAAAAXSSSMMAXXXXAASXMAXMAASXMXSMM
+XMASXMSAAAAMAMXXAAXAAXXMAXAAMXSMMMAMXSAMASXSAMXSAAXXMMXMAXAXSMSAMAMASMMSMAMSASXSXMMSMMAAMSSSMXXMXMMAMSMMXMXMMMMMSMAXAXSMSMASXSMMMMSSMXXXXMXX
+MSASAMMMMMMMSMMSAMXXAMXASMSMMAXXXMMSAMAMXMXXXMAXXMMMASAMSMSMSAMASAMXSAAAXAMXMAXSMMAAXAXXXAAAMSMMAXXMASAMAMXXXMAXSMMMSMMAAAMMXMAAAAXAXSMSMSAS
+AMAXAMXMXSXAXAXSMMMMAAMXXAXMMMSMXXXMAMMMAMAMXMSSSMSAMXAMXAXASMMXSASASMSSSMSSSMAXAMSSSSSSMMSMMMASMXSAXSAMXXXMASAMXAAXMSMMMSXMAXSMSMSAMAAAAAAS
+SSSMXSMMAXMMSXMXAAXMSXMMMSMMAXAASMMMAMAAAMASAAXAXMAMXMXMMXMMMXMMSAMASAMXAXXAAMXMXMAAAMAAXAAAAMMMXAXXXMASMMSXMASASXSMMASAXMAMSMMAXAXMMMXMSMSS
+MAAMAXAMSSSXSMASMMSXMASAAAASXSXSXAMSMSMSXSASMSMSMSSMMAXXMXMXMXXAMXMAMMMSMMASXMXSASMMMMSMMSSSMMAMMMMSXSASAAXASAXMMAAMXAXMMMAMXAMSMMMASXXXXXAX
+MMXMXSMMMAMAMMMMAASASAMMMXMMAMXMMSMAXAMXXMAXXMAXAAXMAXAAMSMASMMMSAMMSAMAAXAMAMASMSAMXXAXMMMXMSAMAAAMMMASMMSMMXMASMMXMMSAASMMSMMMAASXMASMMMAS
+MXMSMMXAMAMAMMSSSMSAMMSSSSMMXMAXMASMSSSMXSAMXMSMMMXSASXSMASASAAAXASASMSXSMMSMMXXXSMMSSMSXMMAMSAASMSSXMXMXMAXSMSXMXXXASAMXSAAXAAMSMSASAMAASXS
+AMAAXMAMSXXXMXMAMAMAMSAAAAASAMXSAAXXAXAXAXSSXXMASAAMAAAXXMMSXMMSXMMASASAMXMAMXMSMMXMAASXAAMAMMMMMAMMXSMMSSMMSAMXMXMMMAAXAMMSMSXMXXMXMAMXMSAM
+MMSXSMMMMMMSMXMAMXMSMMMXSXMSXMAMMMSMSSMMSXXXXXXAMMXMSMMMSXMMMSAXAMMXMASXMASMSAAAAMAMXSMMMMSMSAMXMAMXAXAAAAMXMAMXSASASMMMXMAAMXMMMSMMSSMMXMMM
+XAAMAMXAAAAAAASMMMXXAXXMAMMXXMAMAAAXXAXAXMSMSMSXSXXXXXSAXAAMAMASAMSAMXMASXMASMSMXSASXMAMSASMSAMASXMMSSMMXSMMSAMASASXSAMMAMXSMMXAAAAMAMXMAMAS
+MMSXSMSMSMSMMMMAAXMSXMXAAASAMMSMMSMSSMMMMAAAAAAAMAMSMMMMSSMMAMMMXASASMSAMXMAMAMAXSASMMAMMASXXAMAMASAMMASAXXAXMSXMXMXSAMMAXMAMAXMXSXMASMSMSAS
+MSMXMASAXXMXSXSSMSMAMMMSSSMASAAMAMAMXXAMXMSSMMMSMAMAAXAXMAXSAMMAMXSAMAMSMXMASXMSMMXMMMASMSMMXXMASAMXSMAMAMMXSAXMAMMXSAMSAMSAMSASAAAMASXAAMAS
+XAMSMAMAMAMMAAXMAAXAAMAAMAXAMXXMASAXSSXSAAXMMSAXMAMXMSSSSMMSMSMXSAMXMXMAMAMAAAMXAMMSXSASXAAXMSSMMMSAMMXSXSAAMAMAXASASAMMAMXAAXAAMSSMASXMMMMM
+SAAXMASASAMAMMMMSMSSSMMSSSMSXSXMASAMXAAMMMMAMMMSMSSSMAAXAXAMSAMXMXASMMSXXSSMMSMASAAAMMASXMMMXAAXAAMASAASAMASMMXXSAAAMSAMXMMSMMMMXAAXMXXXAAAS
+SMSMSASMXMXSAMAXMXAAXMAAAMAMAMXXAMASMMMXXAXAMAMMAAAAMAMSXMXSAMXSAMXMAAXXXMAXAAXAXMSMAMXMAMSSMSSMMSSMMMXMXMXMAMAAMMMXMAMMSXMAXXMXMSSMMMMSSSSM
+XAAAMASMSMAMASMSSMMSMMSMMMAMXMXMASXMAMAASXSXSASMMMSXMAMMAMXMAMAAAMMSMMMSXSAMSSMSXXMXXXMXMSAMAAXMAAMASMMSSMASAMXSXXXMAMAMXAMSSXMAMXMAAAXAAXMX
+MMMSMMMAAMASAMAMAMAMXAXXXXXMAMXSAMMXMMMXXMAASMSAXAXASMMSAMASMMSSMMMAAAAAAMAMXXAAMAMMSMMSXSAMMMSMMSSMMAAXAMASMMAMMXMMASXMSSMAMMSMSASXMSMMSMAA
+XXXMASMSMSAMXSASAMASMXMASMASMSAMASXXSAMXXMMMMASXMMSAMAASAMXSAXMAXSSSSMSSXMAAXMSMMMXAAASXASXMASAMXXAXSMMSAMXSAMMXSAAMASAAAAMAMXAMXASXAAASAASM
+XSXMSAMXMAMXXSMSASASAMXAXSAMXMMXSAMXSASAXXSXMXMSMXMXMMMSSMMSXMSAMXXMAMXXASXMSAMXXMMSSSMMMMXSXSXSXSAMXAXMXMASAMMASXSMMSMMMSSSXMASMSMMSSSMSMMX

utils.zig

@@ -1,59 +1,32 @@
 const std = @import("std");
 
-// pub const LineReader = struct {
+pub fn rangeComptime(comptime n: usize) [n]usize {
-//     const FileReader = std.fs.File.Reader;
+    var array: [n]usize = undefined;
-//     const BufferedReader = std.io.BufferedReader(4096, FileReader);
-//     const Reader = std.io.Reader(*BufferedReader, std.fs.File.Reader.Error, BufferedReader.read);
 
-//     alloc: std.mem.Allocator,
+    for (0.., &array) |i, *elem| {
+        elem.* = i;
+    }
 
-//     file: std.fs.File,
+    return array;
+}
 
-//     line_buf: std.ArrayList(u8),
+pub fn range(alloc: std.mem.Allocator, n: usize) ![]usize {
+    var array = try alloc.alloc(usize, n);
 
-//     buf_reader: *BufferedReader,
+    for (0..n) |i| {
-//     reader: Reader,
+        array[i] = i;
+    }
 
-//     pub fn init(alloc: std.mem.Allocator, filename: []const u8) !LineReader {
+    return array;
-//         const file = try std.fs.cwd().openFile(filename, .{});
+}
 
-//         const file_reader = file.reader();
+pub fn printSlice(comptime T: type, slice: []const T) void {
-
+    std.debug.print("[ ", .{});
-//         const buf_reader = try alloc.create(BufferedReader);
+    for (slice[0 .. slice.len - 1]) |x| {
-//         buf_reader.* = std.io.bufferedReader(file_reader);
+        std.debug.print("{}, ", .{x});
-
+    }
-//         const reader: Reader = Reader{ .context = buf_reader };
+    std.debug.print("{} ]", .{slice[slice.len - 1]});
-
+}
-//         const line_buf = std.ArrayList(u8).init(alloc);
-
-//         return .{
-//             .alloc = alloc,
-//             .file = file,
-//             .line_buf = line_buf,
-//             .buf_reader = buf_reader,
-//             .reader = reader,
-//         };
-//     }
-
-//     pub fn deinit(self: *LineReader) void {
-//         self.file.close();
-
-//         self.line_buf.deinit();
-
-//         self.alloc.destroy(self.buf_reader);
-//     }
-
-//     pub fn next(self: *LineReader) !?[]u8 {
-//         self.line_buf.clearRetainingCapacity();
-
-//         self.reader.streamUntilDelimiter(self.line_buf.writer(), '\n', 4096) catch |err| switch (err) {
-//             error.EndOfStream => return null,
-//             else => return err,
-//         };
-
-//         return self.line_buf.items;
-//     }
-// };
 
 pub const FileReader = struct {
     const BufferedReader = std.io.BufferedReader(4096, std.fs.File.Reader);
@@ -150,3 +123,7 @@ pub fn NumberParser(comptime T: type) type {
 pub fn numberParser(comptime T: type, input: []const u8) NumberParser(T) {
     return NumberParser(T){ .token_it = std.mem.tokenizeScalar(u8, input, ' ') };
 }
+
+pub fn numberParserWithDelimiter(comptime T: type, input: []const u8, delimiter: u8) NumberParser(T) {
+    return NumberParser(T){ .token_it = std.mem.tokenizeScalar(u8, input, delimiter) };
+}