Add day 25

Days/Day16.cs

@@ -0,0 +1,289 @@
+using System.Numerics;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day16 : Day
+{
+    public override int Number => 16;
+    public override string Name => "Reindeer Maze";
+
+    private const int Size = 141;
+
+    private const char Wall = '#';
+    private const char Empty = '.';
+    private const char Start = 'S';
+    private const char End = 'E';
+
+    private static readonly Point DirectionUp = new(0, -1);
+    private static readonly Point DirectionDown = new(0, 1);
+    private static readonly Point DirectionLeft = new(-1, 0);
+    private static readonly Point DirectionRight = new(1, 0);
+
+    public override void RunPart1(bool display = true)
+    {
+        var (maze, start, end) = ParseMaze();
+
+        var visited = new Dictionary<(Point Position, Point Direction), int>();
+
+        var minimumScore = int.MaxValue;
+
+        var toVisit = new Queue<(Point Position, Point Direction, int Score)>();
+
+        toVisit.Enqueue((start, DirectionRight, 0));
+
+        while (toVisit.Count > 0)
+        {
+            var (position, direction, score) = toVisit.Dequeue();
+
+            if (visited.TryGetValue((position, direction), out var savedScore) && savedScore <= score)
+            {
+                continue;
+            }
+
+            visited[(position, direction)] = score;
+
+            // Reached end
+            if (position == end)
+            {
+                if (score < minimumScore)
+                {
+                    minimumScore = score;
+                }
+
+                continue;
+            }
+
+            // Try forward if there is no wall
+            var destination = position + direction;
+
+            if (maze[destination.X, destination.Y] is not Wall)
+            {
+                toVisit.Enqueue((destination, direction, score + 1));
+            }
+
+            // Also try changing direction
+            toVisit.Enqueue((position, NextDirection(direction), score + 1000));
+            toVisit.Enqueue((position, PreviousDirection(direction), score + 1000));
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Lowest score: [yellow]{minimumScore}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        var (maze, start, end) = ParseMaze();
+
+        var visited = new Dictionary<(Point Position, Point Direction), int>();
+
+        var minimumScore = int.MaxValue;
+
+        var toVisit = new Queue<(Point Position, Point Direction, int Score)>();
+
+        toVisit.Enqueue((start, DirectionRight, 0));
+
+        // First we need to find minimum score
+        while (toVisit.Count > 0)
+        {
+            var (position, direction, score) = toVisit.Dequeue();
+
+            if (visited.TryGetValue((position, direction), out var savedScore) && savedScore <= score)
+            {
+                continue;
+            }
+
+            visited[(position, direction)] = score;
+
+            // Reached end
+            if (position == end)
+            {
+                if (score < minimumScore)
+                {
+                    minimumScore = score;
+                }
+
+                continue;
+            }
+
+            // Try forward if there is no wall
+            var destination = position + direction;
+
+            if (maze[destination.X, destination.Y] is not Wall)
+            {
+                toVisit.Enqueue((destination, direction, score + 1));
+            }
+
+            // Also try changing direction
+            toVisit.Enqueue((position, NextDirection(direction), score + 1000));
+            toVisit.Enqueue((position, PreviousDirection(direction), score + 1000));
+        }
+
+        // Now that we have minimum score, we need to find all the paths that lead to this score
+        var toVisitPath = new Stack<(Point Position, Point Direction, int Score, List<Point> Path)>();
+        toVisitPath.Push((start, DirectionRight, 0, []));
+
+        var minimumScorePaths = new List<List<Point>>();
+
+        while (toVisitPath.Count > 0)
+        {
+            var (position, direction, score, path) = toVisitPath.Pop();
+
+            if (score > minimumScore)
+            {
+                continue;
+            }
+
+            if (visited.TryGetValue((position, direction), out var savedScore) && savedScore < score)
+            {
+                continue;
+            }
+
+            path.Add(position);
+
+            // Reached end
+            if (position == end)
+            {
+                minimumScorePaths.Add(path);
+
+                continue;
+            }
+
+            // Try forward if there is no wall
+            var destination = position + direction;
+
+            if (maze[destination.X, destination.Y] is not Wall)
+            {
+                toVisitPath.Push((destination, direction, score + 1, path));
+            }
+
+            // Also try changing direction
+            toVisitPath.Push((position, NextDirection(direction), score + 1000, path.ToList()));
+            toVisitPath.Push((position, PreviousDirection(direction), score + 1000, path.ToList()));
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Unique positions in optimal paths: [yellow]{minimumScorePaths.SelectMany(l => l).ToHashSet().Count}[/][/]");
+        }
+    }
+
+    private (char[,] Maze, Point Start, Point end) ParseMaze()
+    {
+        var maze = new char[Size, Size];
+        Point start = default;
+        Point end = default;
+
+        var y = 0;
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            var x = 0;
+            foreach (var symbol in line)
+            {
+                if (symbol is Start)
+                {
+                    start = new Point(x, y);
+
+                    maze[x, y] = Empty;
+                }
+                else if (symbol is End)
+                {
+                    end = new Point(x, y);
+
+                    maze[x, y] = Empty;
+                }
+                else
+                {
+                    maze[x, y] = symbol;
+                }
+
+                x++;
+            }
+
+            y++;
+        }
+
+        return (maze, start, end);
+    }
+
+    private static Point NextDirection(Point direction)
+    {
+        if (direction == DirectionUp)
+        {
+            return DirectionRight;
+        }
+
+        if (direction == DirectionRight)
+        {
+            return DirectionDown;
+        }
+
+        if (direction == DirectionDown)
+        {
+            return DirectionLeft;
+        }
+
+        if (direction == DirectionLeft)
+        {
+            return DirectionUp;
+        }
+
+        throw new ArgumentException("Invalid direction", nameof(direction));
+    }
+
+    private static Point PreviousDirection(Point direction)
+    {
+        if (direction == DirectionUp)
+        {
+            return DirectionLeft;
+        }
+
+        if (direction == DirectionLeft)
+        {
+            return DirectionDown;
+        }
+
+        if (direction == DirectionDown)
+        {
+            return DirectionRight;
+        }
+
+        if (direction == DirectionRight)
+        {
+            return DirectionUp;
+        }
+
+        throw new ArgumentException("Invalid direction", nameof(direction));
+    }
+
+    private readonly record struct Point(int X, int Y)
+        : IAdditionOperators<Point, Point, Point>,
+            ISubtractionOperators<Point, Point, Point>,
+            IMultiplyOperators<Point, int, Point>
+    {
+        public static Point operator +(Point left, Point right)
+        {
+            return new Point(left.X + right.X, left.Y + right.Y);
+        }
+
+        public static Point operator -(Point left, Point right)
+        {
+            return new Point(left.X - right.X, left.Y - right.Y);
+        }
+
+        public static Point operator *(Point left, int right)
+        {
+            return new Point(left.X * right, left.Y * right);
+        }
+
+        public static Point operator *(int left, Point right)
+        {
+            return new Point(right.X * left, right.Y * left);
+        }
+
+        public static implicit operator Point((int X, int Y) point)
+            => new(point.X, point.Y);
+    }
+}

Days/Day17.cs

@@ -0,0 +1,247 @@
+using System.Numerics;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day17 : Day
+{
+    public override int Number => 17;
+    public override string Name => "Chronospatial Computer";
+
+    public override void RunPart1(bool display = true)
+    {
+        var (registerA, registerB, registerC, program) = ParseState();
+
+        var toOutput = new List<int>();
+        var instructionPointer = 0;
+
+        while (instructionPointer < program.Length)
+        {
+            var opCode = program[instructionPointer];
+
+            var isComboOperand = opCode switch
+            {
+                0 => true,
+                1 => false,
+                2 => true,
+                3 => false,
+                4 => false,
+                5 => true,
+                6 => true,
+                7 => true,
+                _ => throw new ArgumentOutOfRangeException(nameof(opCode))
+            };
+
+            var operand = (isComboOperand, program[instructionPointer + 1]) switch
+            {
+                (false, var literalValue) => literalValue,
+                (true, 0) => 0,
+                (true, 1) => 1,
+                (true, 2) => 2,
+                (true, 3) => 3,
+                (true, 4) => registerA,
+                (true, 5) => registerB,
+                (true, 6) => registerC,
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            switch (opCode)
+            {
+                // adv
+                case 0:
+                    registerA = (int)(registerA / Math.Pow(2, operand));
+                    break;
+
+                // bxl
+                case 1:
+                    registerB = registerB ^ operand;
+                    break;
+
+                // bst
+                case 2:
+                    registerB = operand % 8;
+                    break;
+
+                // jnz
+                case 3:
+                    if (registerA is not 0)
+                    {
+                        instructionPointer = operand - 2;
+                    }
+                    break;
+
+                // bxc
+                case 4:
+                    registerB = registerB ^ registerC;
+                    break;
+
+                // out
+                case 5:
+                    toOutput.Add(operand % 8);
+                    break;
+
+                // bdv
+                case 6:
+                    registerB = (int)(registerA / Math.Pow(2, operand));
+                    break;
+
+                // cdv
+                case 7:
+                    registerC = (int)(registerA / Math.Pow(2, operand));
+                    break;
+            }
+
+            instructionPointer += 2;
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Output: [yellow]{string.Join(',', toOutput)}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        var (_, originalRegisterB, originalRegisterC, program) = ParseState();
+        var toOutput = new List<int>();
+        var instructionPointer = 0;
+
+        var finalRegisterA = 0;
+
+        AnsiConsole.Status().Start("Computing (0)...", ctx =>
+        {
+            for (var initialRegisterA = 0; initialRegisterA < int.MaxValue; initialRegisterA++)
+            {
+                // Reset state
+                var registerA = initialRegisterA;
+                var registerB = originalRegisterB;
+                var registerC = originalRegisterC;
+
+                toOutput.Clear();
+                instructionPointer = 0;
+
+                while (instructionPointer < program.Length)
+                {
+                    var opCode = program[instructionPointer];
+
+                    var isComboOperand = opCode switch
+                    {
+                        0 => true,
+                        1 => false,
+                        2 => true,
+                        3 => false,
+                        4 => false,
+                        5 => true,
+                        6 => true,
+                        7 => true,
+                        _ => throw new ArgumentOutOfRangeException(nameof(opCode))
+                    };
+
+                    var operand = (isComboOperand, program[instructionPointer + 1]) switch
+                    {
+                        (false, var literalValue) => literalValue,
+                        (true, 0) => 0,
+                        (true, 1) => 1,
+                        (true, 2) => 2,
+                        (true, 3) => 3,
+                        (true, 4) => registerA,
+                        (true, 5) => registerB,
+                        (true, 6) => registerC,
+                        _ => throw new ArgumentOutOfRangeException()
+                    };
+
+                    switch (opCode)
+                    {
+                        // adv
+                        case 0:
+                            registerA = (int)(registerA / Math.Pow(2, operand));
+                            break;
+
+                        // bxl
+                        case 1:
+                            registerB = registerB ^ operand;
+                            break;
+
+                        // bst
+                        case 2:
+                            registerB = operand % 8;
+                            break;
+
+                        // jnz
+                        case 3:
+                            if (registerA is not 0)
+                            {
+                                instructionPointer = operand - 2;
+                            }
+                            break;
+
+                        // bxc
+                        case 4:
+                            registerB = registerB ^ registerC;
+                            break;
+
+                        // out
+                        case 5:
+                            toOutput.Add(operand % 8);
+                            break;
+
+                        // bdv
+                        case 6:
+                            registerB = (int)(registerA / Math.Pow(2, operand));
+                            break;
+
+                        // cdv
+                        case 7:
+                            registerC = (int)(registerA / Math.Pow(2, operand));
+                            break;
+                    }
+
+                    instructionPointer += 2;
+                }
+
+                if (initialRegisterA % 1000 == 0)
+                {
+                    ctx.Status($"Computing ({initialRegisterA})...");
+                }
+
+                // Check if output is the program itself
+                if (toOutput.SequenceEqual(program))
+                {
+                    finalRegisterA = initialRegisterA;
+
+                    break;
+                }
+            }
+        });
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Lowest possible value for register A to output itself: [yellow]{finalRegisterA}[/][/]");
+        }
+    }
+
+    private (int RegisterA, int RegisterN, int RegisterC, int[] Program) ParseState()
+    {
+        var lineIterator = Input.AsSpan().EnumerateLines();
+
+        lineIterator.MoveNext();
+        var registerA = int.Parse(lineIterator.Current[(lineIterator.Current.IndexOf(':') + 2)..]);
+
+        lineIterator.MoveNext();
+        var registerB = int.Parse(lineIterator.Current[(lineIterator.Current.IndexOf(':') + 2)..]);
+
+        lineIterator.MoveNext();
+        var registerC = int.Parse(lineIterator.Current[(lineIterator.Current.IndexOf(':') + 2)..]);
+
+        lineIterator.MoveNext();
+        lineIterator.MoveNext();
+
+        var program = lineIterator.Current[(lineIterator.Current.IndexOf(':') + 2)..]
+            .ToString()
+            .Split(',')
+            .Select(int.Parse)
+            .ToArray();
+
+        return (registerA, registerB, registerC, program);
+    }
+}

Days/Day18.cs

@@ -0,0 +1,204 @@
+using System.Numerics;
+using System.Runtime.Intrinsics.X86;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day18 : Day
+{
+    public override int Number => 18;
+    public override string Name => "RAM Run";
+
+    private const int Size = 71;
+
+    private const char Corrupted = '#';
+    private const char Empty = ' ';
+
+    public override void RunPart1(bool display = true)
+    {
+        var grid = ParseGrid(1024);
+
+        var visited = new Dictionary<Point, int>();
+        var toVisit = new Queue<(Point Position, int Score)>();
+
+        var end = new Point(Size - 1, Size - 1);
+
+        var minimumScore = int.MaxValue;
+
+        toVisit.Enqueue((new Point(0, 0), 0));
+
+        while (toVisit.Count > 0)
+        {
+            var (position, score) = toVisit.Dequeue();
+
+            // Cannot go out of bounds
+            if (position is { X: < 0 or >= Size } or { Y: < 0 or >= Size })
+            {
+                continue;
+            }
+
+            // Cannot go onto a corrupted space
+            if (grid[position.X, position.Y] is Corrupted)
+            {
+                continue;
+            }
+
+            if (visited.TryGetValue(position, out var savedScore) && savedScore <= score)
+            {
+                continue;
+            }
+
+            visited[position] = score;
+
+            // End
+            if (position == end)
+            {
+                if (score < minimumScore)
+                {
+                    minimumScore = score;
+                }
+
+                continue;
+            }
+
+            toVisit.Enqueue((position + (1, 0), score + 1));
+            toVisit.Enqueue((position + (-1, 0), score + 1));
+            toVisit.Enqueue((position + (0, 1), score + 1));
+            toVisit.Enqueue((position + (0, -1), score + 1));
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Minimum number of steps to reach the exit: [yellow]{minimumScore}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        (int X, int Y)[] bytesToFall = Input.ReadAllLines()
+            .Select(line => line.Split(','))
+            .Select(split => (int.Parse(split[0]), int.Parse(split[1])))
+            .ToArray();
+
+        var nextByteIndex = 1024;
+        var grid = ParseGrid(1024);
+
+        while (true)
+        {
+            var nextByte = bytesToFall[nextByteIndex];
+
+            grid[nextByte.X, nextByte.Y] = Corrupted;
+
+            if (!IsGridCompletable())
+            {
+                break;
+            }
+
+            nextByteIndex++;
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Grid will be blocked at byte n°{nextByteIndex} at position: [yellow]{bytesToFall[nextByteIndex]}[/][/]");
+        }
+
+        return;
+
+        bool IsGridCompletable()
+        {
+            var visited = new HashSet<Point>();
+            var toVisit = new Queue<Point>();
+
+            var end = new Point(Size - 1, Size - 1);
+
+            toVisit.Enqueue(new Point(0, 0));
+
+            while (toVisit.Count > 0)
+            {
+                var position = toVisit.Dequeue();
+
+                // Cannot go out of bounds
+                if (position is { X: < 0 or >= Size } or { Y: < 0 or >= Size })
+                {
+                    continue;
+                }
+
+                // Cannot go onto a corrupted space
+                if (grid[position.X, position.Y] is Corrupted)
+                {
+                    continue;
+                }
+
+                if (!visited.Add(position))
+                {
+                    continue;
+                }
+
+                // End
+                if (position == end)
+                {
+                    return true;
+                }
+
+                toVisit.Enqueue(position + (1, 0));
+                toVisit.Enqueue(position + (-1, 0));
+                toVisit.Enqueue(position + (0, 1));
+                toVisit.Enqueue(position + (0, -1));
+            }
+
+            return false;
+        }
+    }
+
+    private char[,] ParseGrid(int limit)
+    {
+        var grid = new char[Size, Size];
+
+        var counter = 0;
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            if (counter >= limit)
+            {
+                break;
+            }
+
+            var x = int.Parse(line[..line.IndexOf(',')]);
+            var y = int.Parse(line[(line.IndexOf(',') + 1)..]);
+
+            grid[x, y] = Corrupted;
+
+            counter++;
+        }
+
+        return grid;
+    }
+
+    private readonly record struct Point(int X, int Y)
+        : IAdditionOperators<Point, Point, Point>,
+            ISubtractionOperators<Point, Point, Point>,
+            IMultiplyOperators<Point, int, Point>
+    {
+        public static Point operator +(Point left, Point right)
+        {
+            return new Point(left.X + right.X, left.Y + right.Y);
+        }
+
+        public static Point operator -(Point left, Point right)
+        {
+            return new Point(left.X - right.X, left.Y - right.Y);
+        }
+
+        public static Point operator *(Point left, int right)
+        {
+            return new Point(left.X * right, left.Y * right);
+        }
+
+        public static Point operator *(int left, Point right)
+        {
+            return new Point(right.X * left, right.Y * left);
+        }
+
+        public static implicit operator Point((int X, int Y) point)
+            => new(point.X, point.Y);
+    }
+}

Days/Day19.cs

@@ -0,0 +1,179 @@
+using System.Collections.Frozen;
+using System.Numerics;
+using System.Runtime.Intrinsics.X86;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day19 : Day
+{
+    public override int Number => 19;
+    public override string Name => "Linen Layout";
+
+    public override void RunPart1(bool display = true)
+    {
+        var (towels, patterns) = ParseInput();
+        var impossiblePatterns = new HashSet<string>();
+
+        var possiblePatterns = 0;
+
+        foreach (var pattern in patterns)
+        {
+            // Check if it's possible to make this pattern
+            if (CheckPattern(pattern))
+            {
+                possiblePatterns++;
+            }
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Number of designs that are possible: [yellow]{possiblePatterns}[/][/]");
+        }
+
+        return;
+
+        bool CheckPattern(ReadOnlySpan<char> pattern)
+        {
+            // Console.WriteLine($"Checking '{pattern}'");
+
+            if (pattern.Length is 0)
+            {
+                return true;
+            }
+
+            if (impossiblePatterns.Contains(pattern.ToString()))
+            {
+                return false;
+            }
+
+            var prefix = pattern[0];
+
+            if (!towels.TryGetValue(prefix, out var towelsList))
+            {
+                impossiblePatterns.Add(pattern.ToString());
+
+                return false;
+            }
+
+            foreach (var towel in towelsList)
+            {
+                if (pattern.StartsWith(towel) && CheckPattern(pattern[towel.Length..]))
+                {
+                    return true;
+                }
+            }
+
+            impossiblePatterns.Add(pattern.ToString());
+
+            return false;
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        var (towels, patterns) = ParseInput();
+        var impossiblePatterns = new HashSet<string>();
+        var knownPatterns = new Dictionary<string, long>();
+
+        var possibleCombinations = 0L;
+
+        foreach (var pattern in patterns)
+        {
+            // Check if it's possible to make this pattern
+            possibleCombinations += CheckPattern(pattern);
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Number of combinations that are possible: [yellow]{possibleCombinations}[/][/]");
+        }
+
+        return;
+
+        long CheckPattern(ReadOnlySpan<char> pattern)
+        {
+            if (pattern.Length is 0)
+            {
+                return 1;
+            }
+
+            if (impossiblePatterns.Contains(pattern.ToString()))
+            {
+                return 0;
+            }
+
+            if (knownPatterns.TryGetValue(pattern.ToString(), out var count))
+            {
+                return count;
+            }
+
+            var prefix = pattern[0];
+
+            if (!towels.TryGetValue(prefix, out var towelsList))
+            {
+                impossiblePatterns.Add(pattern.ToString());
+
+                return 0;
+            }
+
+            var possibilities = 0L;
+
+            foreach (var towel in towelsList)
+            {
+                if (pattern.StartsWith(towel))
+                {
+                    possibilities += CheckPattern(pattern[towel.Length..]);
+                }
+            }
+
+            if (possibilities is 0)
+            {
+                impossiblePatterns.Add(pattern.ToString());
+            }
+            else
+            {
+                knownPatterns.Add(pattern.ToString(), possibilities);
+            }
+
+            return possibilities;
+        }
+    }
+
+    private (FrozenDictionary<char, List<string>> Towels, List<string> Patterns) ParseInput()
+    {
+        var towels = new Dictionary<char, List<string>>();
+        var patterns = new List<string>();
+
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            if (towels.Count is 0)
+            {
+                var split = line.Split(", ");
+
+                foreach (var range in split)
+                {
+                    var towel = line[range].Trim();
+
+                    var prefix = towel[0];
+
+                    if (!towels.TryGetValue(prefix, out var towelsList))
+                    {
+                        towelsList = [];
+                        towels[prefix] = towelsList;
+                    }
+
+                    towelsList.Add(towel.ToString());
+                }
+            }
+            else if (!line.IsWhiteSpace())
+            {
+                var pattern = line.Trim();
+
+                patterns.Add(pattern.ToString());
+            }
+        }
+
+        return (towels.ToFrozenDictionary(), patterns);
+    }
+}

Days/Day20.cs

@@ -0,0 +1,288 @@
+using System.Collections.Frozen;
+using System.Numerics;
+using System.Runtime.Intrinsics.X86;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day20 : Day
+{
+    public override int Number => 20;
+    public override string Name => "Race Condition";
+
+    private const int Size = 141;
+    private const char Wall = '#';
+    private const char Empty = '.';
+
+    private readonly List<Point> _cheatOffsets =
+    [
+        (2, 0),
+        (1, 1),
+        (0, 2),
+        (-1, 1),
+        (-2, 0),
+        (-1, -1),
+        (0, -2),
+        (1, -1)
+    ];
+
+    public override void RunPart1(bool display = true)
+    {
+        var (map, start, end) = ParseMap();
+
+        // Find track path
+        var trackPath = new List<Point>();
+        var distanceFromStart = new Dictionary<Point, int>();
+
+        var position = start;
+
+        var distance = 0;
+        while (position != end)
+        {
+           trackPath.Add(position);
+           distanceFromStart[position] = distance;
+
+           // Find next track position
+           distance++;
+           var up = position + new Point(0, -1);
+           if (up is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[up.X, up.Y] is not Wall && !distanceFromStart.ContainsKey(up))
+           {
+               position = up;
+
+               continue;
+           }
+
+           var down = position + new Point(0, 1);
+           if (down is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[down.X, down.Y] is not Wall && !distanceFromStart.ContainsKey(down))
+           {
+               position = down;
+
+               continue;
+           }
+
+           var left = position + new Point(-1, 0);
+           if (left is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[left.X, left.Y] is not Wall && !distanceFromStart.ContainsKey(left))
+           {
+               position = left;
+
+               continue;
+           }
+
+           var right = position + new Point(1, 0);
+           if (right is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[right.X, right.Y] is not Wall && !distanceFromStart.ContainsKey(right))
+           {
+               position = right;
+           }
+        }
+
+        // Also add end
+        trackPath.Add(position);
+        distanceFromStart[position] = distance;
+
+        var cheats = new Dictionary<(Point StartPosition, Point EndPosition), int>();
+
+        // Now return to start and try all possible combination of cheats for each track position
+        foreach (var trackPosition in trackPath)
+        {
+            var originDistance = distanceFromStart[trackPosition];
+
+            foreach (var cheatOffset in _cheatOffsets)
+            {
+                var cheatDestination = trackPosition + cheatOffset;
+
+                if (cheatDestination.X is < 0 or >= Size || cheatDestination.Y is < 0 or >= Size)
+                {
+                    continue;
+                }
+
+                if (map[cheatDestination.X, cheatDestination.Y] is Wall)
+                {
+                    continue;
+                }
+
+                var destinationDistance = distanceFromStart[cheatDestination];
+                var savedDistance = destinationDistance - originDistance - 2;
+
+                // Only take into account real shortcuts, not those that do not save time
+                if (savedDistance < 1)
+                {
+                    continue;
+                }
+
+                cheats.Add((trackPosition, cheatDestination), savedDistance);
+            }
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Number of cheats that save at least 100 picoseconds: [yellow]{cheats.Count(c => c.Value >= 100)}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        var (map, start, end) = ParseMap();
+
+        // Find track path
+        var trackPath = new List<Point>();
+        var distanceFromStart = new Dictionary<Point, int>();
+
+        var position = start;
+
+        var distance = 0;
+        while (position != end)
+        {
+           trackPath.Add(position);
+           distanceFromStart[position] = distance;
+
+           // Find next track position
+           distance++;
+           var up = position + new Point(0, -1);
+           if (up is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[up.X, up.Y] is not Wall && !distanceFromStart.ContainsKey(up))
+           {
+               position = up;
+
+               continue;
+           }
+
+           var down = position + new Point(0, 1);
+           if (down is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[down.X, down.Y] is not Wall && !distanceFromStart.ContainsKey(down))
+           {
+               position = down;
+
+               continue;
+           }
+
+           var left = position + new Point(-1, 0);
+           if (left is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[left.X, left.Y] is not Wall && !distanceFromStart.ContainsKey(left))
+           {
+               position = left;
+
+               continue;
+           }
+
+           var right = position + new Point(1, 0);
+           if (right is { X: >= 0 and < Size, Y: >= 0 and < Size } && map[right.X, right.Y] is not Wall && !distanceFromStart.ContainsKey(right))
+           {
+               position = right;
+           }
+        }
+
+        // Also add end
+        trackPath.Add(position);
+        distanceFromStart[position] = distance;
+
+        var cheats = new Dictionary<(Point StartPosition, Point EndPosition), int>();
+
+        // Now return to start and try all possible combination of cheats for each track position
+        foreach (var trackPosition in trackPath)
+        {
+            var originDistance = distanceFromStart[trackPosition];
+
+            foreach (var cheatDestination in trackPath.Where(destination => trackPosition.DistanceTo(destination) <= 20))
+            {
+                var cheatLength = trackPosition.DistanceTo(cheatDestination);
+
+                var destinationDistance = distanceFromStart[cheatDestination];
+                var savedDistance = destinationDistance - originDistance - cheatLength;
+
+                // Only take into account real shortcuts, not those that do not save time
+                if (savedDistance < 1)
+                {
+                    continue;
+                }
+
+                if (cheats.TryGetValue((trackPosition, cheatDestination), out var otherSavedDistance))
+                {
+                    if (savedDistance <= otherSavedDistance)
+                    {
+                        continue;
+                    }
+                }
+
+                cheats[(trackPosition, cheatDestination)] = savedDistance;
+            }
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Number of cheats that save at least 100 picoseconds: [yellow]{cheats.Count(c => c.Value >= 100)}[/][/]");
+        }
+    }
+
+    private (char[,] Map, Point Start, Point End) ParseMap()
+    {
+        var map = new char[Size, Size];
+        Point start = default;
+        Point end = default;
+
+        var y = 0;
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            var x = 0;
+
+            foreach (var symbol in line)
+            {
+                if (symbol == 'S')
+                {
+                    start = new Point(x, y);
+                }
+                else if (symbol == 'E')
+                {
+                    end = new Point(x, y);
+                }
+
+                if (symbol is Wall)
+                {
+                    map[x, y] = Wall;
+                }
+                else
+                {
+                    map[x, y] = Empty;
+                }
+
+                x++;
+            }
+
+            y++;
+        }
+
+        return (map, start, end);
+    }
+
+    private readonly record struct Point(int X, int Y)
+        : IAdditionOperators<Point, Point, Point>,
+            ISubtractionOperators<Point, Point, Point>,
+            IMultiplyOperators<Point, int, Point>
+    {
+        public static Point operator +(Point left, Point right)
+        {
+            return new Point(left.X + right.X, left.Y + right.Y);
+        }
+
+        public static Point operator -(Point left, Point right)
+        {
+            return new Point(left.X - right.X, left.Y - right.Y);
+        }
+
+        public static Point operator *(Point left, int right)
+        {
+            return new Point(left.X * right, left.Y * right);
+        }
+
+        public static Point operator *(int left, Point right)
+        {
+            return new Point(right.X * left, right.Y * left);
+        }
+
+        public static implicit operator Point((int X, int Y) point)
+            => new(point.X, point.Y);
+
+        public int DistanceTo(Point other)
+        {
+            var distance = other - this;
+
+            return Math.Abs(distance.X) + Math.Abs(distance.Y);
+        }
+    }
+}

Days/Day21.cs

@@ -0,0 +1,183 @@
+using System.Collections.Frozen;
+using System.Numerics;
+using System.Runtime.Intrinsics.X86;
+using System.Text;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day21 : Day
+{
+    public override int Number => 21;
+    public override string Name => "Keypad Conundrum";
+
+    private const char Up = '^';
+    private const char Right = '>';
+    private const char Down = 'v';
+    private const char Left = '<';
+    private const char Enter = 'A';
+
+    private readonly Dictionary<char, Point> _numpadPositions = new()
+    {
+        { '7', (0, 0) },
+        { '8', (1, 0) },
+        { '9', (2, 0) },
+        { '4', (0, 1) },
+        { '5', (1, 1) },
+        { '6', (2, 1) },
+        { '1', (0, 2) },
+        { '2', (1, 2) },
+        { '3', (2, 2) },
+        { '0', (1, 3) },
+        { Enter, (2, 3) }
+    };
+
+    private readonly Dictionary<char, Point> _keypadPositions = new()
+    {
+        { Up, (1, 0) },
+        { Enter, (2, 0) },
+        { Left, (0, 1) },
+        { Down, (1, 1) },
+        { Right, (2, 1) }
+    };
+
+    public override void RunPart1(bool display = true)
+    {
+        var codes = ParseCodes();
+        var complexitiesSum = 0;
+
+        foreach (var code in codes)
+        {
+            // Get first keypad sequence
+            var firstKeypadSequence = new StringBuilder();
+            var currentInput = Enter;
+
+            foreach (var digit in code)
+            {
+                firstKeypadSequence.Append(GetNumpadMoveSequence(currentInput, digit));
+
+                currentInput = digit;
+            }
+
+            // Get second keypad sequence
+            var secondKeypadSequence = new StringBuilder();
+            currentInput = Enter;
+
+            foreach (var input in firstKeypadSequence.ToString())
+            {
+                secondKeypadSequence.Append(GetKeypadMoveSequence(currentInput, input));
+
+                currentInput = input;
+            }
+
+            // Get third and last keypad sequence
+            var thirdKeypadSequence = new StringBuilder();
+            currentInput = Enter;
+
+            foreach (var input in secondKeypadSequence.ToString())
+            {
+                thirdKeypadSequence.Append(GetKeypadMoveSequence(currentInput, input));
+
+                currentInput = input;
+            }
+
+            complexitiesSum += thirdKeypadSequence.Length * int.Parse(code.AsSpan()[..^1]);
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Sum of complexities: [yellow]{complexitiesSum}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+
+    }
+
+    private string GetNumpadMoveSequence(char origin, char destination)
+    {
+        var originPosition = _numpadPositions[origin];
+        var destinationPosition = _numpadPositions[destination];
+
+        var move = destinationPosition - originPosition;
+
+        var moveRight = move.X > 0;
+        var moveDown = move.Y > 0;
+
+        var sequence = string.Concat(
+            new string(moveRight ? Right : Left, Math.Abs(move.X)),
+            new string(moveDown ? Down : Up, Math.Abs(move.Y)),
+            Enter.ToString() // Always end on Enter to press key
+        );
+
+        return sequence;
+    }
+
+    private string GetKeypadMoveSequence(char origin, char destination)
+    {
+        var originPosition = _keypadPositions[origin];
+        var destinationPosition = _keypadPositions[destination];
+
+        var move = destinationPosition - originPosition;
+
+        var moveRight = move.X > 0;
+        var moveDown = move.Y > 0;
+
+        var sequence = string.Concat(
+            new string(moveDown ? Down : Up, Math.Abs(move.Y)),
+            new string(moveRight ? Right : Left, Math.Abs(move.X)),
+            Enter.ToString() // Always end on Enter to press key
+        );
+
+        return sequence;
+    }
+
+    private List<string> ParseCodes()
+    {
+        var codes = new List<string>();
+
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            codes.Add(line.ToString());
+        }
+
+        return codes;
+    }
+
+    private readonly record struct Point(int X, int Y)
+        : IAdditionOperators<Point, Point, Point>,
+            ISubtractionOperators<Point, Point, Point>,
+            IMultiplyOperators<Point, int, Point>
+    {
+        public static Point operator +(Point left, Point right)
+        {
+            return new Point(left.X + right.X, left.Y + right.Y);
+        }
+
+        public static Point operator -(Point left, Point right)
+        {
+            return new Point(left.X - right.X, left.Y - right.Y);
+        }
+
+        public static Point operator *(Point left, int right)
+        {
+            return new Point(left.X * right, left.Y * right);
+        }
+
+        public static Point operator *(int left, Point right)
+        {
+            return new Point(right.X * left, right.Y * left);
+        }
+
+        public static implicit operator Point((int X, int Y) point)
+            => new(point.X, point.Y);
+
+        public int DistanceTo(Point other)
+        {
+            var distance = other - this;
+
+            return Math.Abs(distance.X) + Math.Abs(distance.Y);
+        }
+    }
+}

Days/Day22.cs

@@ -0,0 +1,162 @@
+using System.Collections.Frozen;
+using System.Numerics;
+using System.Runtime.Intrinsics.X86;
+using System.Text;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day22 : Day
+{
+    public override int Number => 22;
+    public override string Name => "Monkey Market";
+
+    private const int Iterations = 2000;
+    private const int PruneValue = 16777216;
+
+    public override void RunPart1(bool display = true)
+    {
+        var secretsSum = 0L;
+
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            var secret = long.Parse(line);
+
+            for (var i = 0; i < Iterations; i++)
+            {
+                var result = secret * 64;
+                secret = (secret ^ result) % PruneValue;
+
+                result = secret / 32;
+                secret = (secret ^ result) % PruneValue;
+
+                result = secret * 2048;
+                secret = (secret ^ result) % PruneValue;
+            }
+
+            secretsSum += secret;
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Sum of {Iterations}th secret numbers: [yellow]{secretsSum}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        var maximumBananas = 0L;
+
+        var initialSecrets = Input.ReadAllLines().Select(l => long.Parse(l)).ToArray();
+        var matchSequences = GenerateSequences().ToArray();
+
+        AnsiConsole.Progress().Start(progress =>
+        {
+            var progressTask = progress.AddTask("Finding best sequence", maxValue: matchSequences.Length);
+
+            Parallel.ForEach(matchSequences, matchSequence =>
+            {
+                Span<long> sequence = stackalloc long[4];
+                var currentBananas = 0L;
+
+                for (var initialSecretIndex = 0; initialSecretIndex < initialSecrets.Length; initialSecretIndex++)
+                {
+                    var secret = initialSecrets[initialSecretIndex];
+
+                    for (var i = 0; i < Iterations; i++)
+                    {
+                        var previousSecret = secret;
+
+                        // Compute new secret
+                        var result = secret * 64;
+                        secret = (secret ^ result) % PruneValue;
+
+                        result = secret / 32;
+                        secret = (secret ^ result) % PruneValue;
+
+                        result = secret * 2048;
+                        secret = (secret ^ result) % PruneValue;
+
+                        var lastDigit = secret % 10;
+                        var previousSecretLastDigit = previousSecret % 10;
+
+                        // Update sequence
+                        sequence[0] = sequence[1];
+                        sequence[1] = sequence[2];
+                        sequence[2] = sequence[3];
+                        sequence[3] = lastDigit - previousSecretLastDigit;
+
+                        // Check if sequence match
+                        if (sequence[0] == matchSequence.Item1
+                            && sequence[1] == matchSequence.Item2
+                            && sequence[2] == matchSequence.Item3
+                            && sequence[3] == matchSequence.Item4
+                            && i >= 3)
+                        {
+                            currentBananas += lastDigit;
+
+                            // Go to next monkey
+                            break;
+                        }
+                    }
+
+                    // Stop early if it's not possible to beat current maximum
+                    if (maximumBananas - currentBananas >= ((initialSecrets.Length - initialSecretIndex - 1) * 9))
+                    {
+                        break;
+                    }
+                }
+
+                ExchangeIfGreaterThan(ref maximumBananas, currentBananas);
+
+                progressTask.Increment(1);
+            });
+        });
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Maximum amount of bananas: [yellow]{maximumBananas}[/][/]");
+        }
+
+        return;
+
+        IEnumerable<(long, long, long, long)> GenerateSequences()
+        {
+            for (var a = -9L; a <= 9; a++)
+            {
+                for (var b = -9L; b <= 9; b++)
+                {
+                    for (var c = -9L; c <= 9; c++)
+                    {
+                        for (var d = -9L; d <= 9; d++)
+                        {
+                            yield return (a, b, c, d);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Source: https://stackoverflow.com/a/13323172
+    private static void ExchangeIfGreaterThan(ref long location, long value)
+    {
+        // Read
+        var current = Interlocked.Read(ref location);
+
+        // Compare
+        while (current < value)
+        {
+            // Set
+            var previous = Interlocked.CompareExchange(ref location, value, current);
+
+            // If another thread has set a greater value, we can break
+            // or if previous value is current value, then no other thread has it changed in between
+            if (previous == current || previous >= value) // note: most common case first
+                break;
+
+            // For all other cases, we need another run (read value, compare, set)
+            current = Interlocked.Read(ref location);
+        }
+    }
+}

Days/Day23.cs

@@ -0,0 +1,172 @@
+using System.Collections.Frozen;
+using System.Numerics;
+using System.Runtime.Intrinsics.X86;
+using System.Text;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day23 : Day
+{
+    public override int Number => 23;
+    public override string Name => "LAN Party";
+
+    public override void RunPart1(bool display = true)
+    {
+        var computerLinks = new Dictionary<string, HashSet<string>>();
+
+        // Parse all links
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            var firstComputer = line[..2].ToString();
+            var secondComputer = line[3..].ToString();
+
+            if (!computerLinks.TryGetValue(firstComputer, out var firstLinks))
+            {
+                firstLinks = [];
+                computerLinks[firstComputer] = firstLinks;
+            }
+            firstLinks.Add(secondComputer);
+
+            if (!computerLinks.TryGetValue(secondComputer, out var secondLinks))
+            {
+                secondLinks = [];
+                computerLinks[secondComputer] = secondLinks;
+            }
+            secondLinks.Add(firstComputer);
+        }
+
+        var sets = new HashSet<ComputerSet>();
+
+        foreach (var (firstComputer, firstLinks) in computerLinks)
+        {
+            foreach (var secondComputer in firstLinks)
+            {
+                var thirdComputers = computerLinks[secondComputer].Intersect(firstLinks);
+
+                foreach (var thirdComputer in thirdComputers)
+                {
+                    sets.Add(new ComputerSet(firstComputer, secondComputer, thirdComputer));
+                }
+            }
+        }
+
+        var finalCount = sets.Count(set => set.First.StartsWith('t') || set.Second.StartsWith('t') || set.Third.StartsWith('t'));
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Amount of sets that contain at least one computer that starts with t: [yellow]{finalCount}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        var computerLinks = new Dictionary<string, HashSet<string>>();
+
+        // Parse all links
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            var firstComputer = line[..2].ToString();
+            var secondComputer = line[3..].ToString();
+
+            if (!computerLinks.TryGetValue(firstComputer, out var firstLinks))
+            {
+                firstLinks = [];
+                computerLinks[firstComputer] = firstLinks;
+            }
+            firstLinks.Add(secondComputer);
+
+            if (!computerLinks.TryGetValue(secondComputer, out var secondLinks))
+            {
+                secondLinks = [];
+                computerLinks[secondComputer] = secondLinks;
+            }
+            secondLinks.Add(firstComputer);
+        }
+
+        List<string> largestSet = [];
+
+        AnsiConsole.Status().Start("Starting check...", status =>
+        {
+            var size = 4;
+            while (true)
+            {
+                var ended = true;
+
+                status.Status($"Checking set size: {size}");
+
+                var i = 0;
+                foreach (var (firstComputer, firstLinks) in computerLinks)
+                {
+                    status.Status($"Checking set size: {size} ({i++}/{computerLinks.Count})");
+
+                    if (GenerateLargestSet(firstLinks, size, [ firstComputer ]) is { } largest)
+                    {
+                        largestSet = largest;
+                        size++;
+                        ended = false;
+
+                        break;
+                    }
+                }
+
+                if (ended)
+                {
+                    break;
+                }
+            }
+        });
+
+        var password = string.Join(',', largestSet.Order());
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Password to enter lan party: [yellow]{password}[/][/]");
+        }
+
+        return;
+
+        List<string>? GenerateLargestSet(HashSet<string> set, int targetSize, List<string> selected)
+        {
+            if (selected.Count == targetSize)
+            {
+                return selected;
+            }
+
+            if (set.Count is 0 || (set.Count < (targetSize - selected.Count)))
+            {
+                return null;
+            }
+
+            // Next depth
+            foreach (var computer in set)
+            {
+                var nextSet = set.Intersect(computerLinks[computer]).ToHashSet();
+                var nextSelected = selected.Append(computer).ToList();
+
+                if (GenerateLargestSet(nextSet, targetSize, nextSelected) is { } largest)
+                {
+                    return largest;
+                }
+            }
+
+            return null;
+        }
+    }
+
+    private record ComputerSet(string First, string Second, string Third) : IEquatable<ComputerSet>
+    {
+        public virtual bool Equals(ComputerSet? other)
+        {
+            return other is not null &&
+                   (First == other.First || First == other.Second || First == other.Third) &&
+                   (Second == other.First || Second == other.Second || Second == other.Third) &&
+                   (Third == other.First || Third == other.Second || Third == other.Third);
+        }
+
+        public override int GetHashCode()
+        {
+            return First.GetHashCode() * Second.GetHashCode() * Third.GetHashCode();
+        }
+    }
+}

Days/Day24.cs

@@ -0,0 +1,370 @@
+using System.Collections.Frozen;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics.X86;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualBasic;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day24 : Day
+{
+    public override int Number => 24;
+    public override string Name => "Crossed Wires";
+
+    public override void RunPart1(bool display = true)
+    {
+        var (signals, gates, zGates) = ParseInput();
+
+        while (zGates.Count > 0)
+        {
+            foreach (var (inputLeft, inputRight, output, logicOperator) in gates)
+            {
+                if (!signals.TryGetValue(inputLeft, out var inputLeftValue) ||
+                    !signals.TryGetValue(inputRight, out var inputRightValue))
+                {
+                    continue;
+                }
+
+                signals[output] = Compute(inputLeftValue, inputRightValue, logicOperator);
+
+                if (output.StartsWith('z'))
+                {
+                    zGates.Remove(output);
+                }
+            }
+        }
+
+        var zOutputValue = signals
+            .Where(s => s.Key.StartsWith('z'))
+            .Select(s => new { Index = int.Parse(s.Key[1..]), Value = (long)s.Value })
+            .Sum(s => s.Value << s.Index);
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Value output on z signal: [yellow]{zOutputValue}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+        var (initialSignals, initialGates, initialZGates) = ParseInput();
+
+        var xInputValue = initialSignals
+            .Where(s => s.Key.StartsWith('x'))
+            .Select(s => new { Index = int.Parse(s.Key[1..]), Value = (long)s.Value })
+            .Sum(s => s.Value << s.Index);
+
+        var yInputValue = initialSignals
+            .Where(s => s.Key.StartsWith('y'))
+            .Select(s => new { Index = int.Parse(s.Key[1..]), Value = (long)s.Value })
+            .Sum(s => s.Value << s.Index);
+
+        // Find wires that need to be changed
+        const long initialZValue = 58740594706150L;
+        var targetZValue = xInputValue + yInputValue;
+
+        var difference = targetZValue ^ initialZValue;
+        var possibleChange = new HashSet<string>();
+
+        for (var i = 0; i < sizeof(long) * 8; i++)
+        {
+            if (((1 << i) & difference) != 0)
+            {
+                possibleChange.Add($"z{i:D2}");
+            }
+        }
+
+        // Find all dependencies
+        int initialSize;
+        do
+        {
+            initialSize = possibleChange.Count;
+
+            foreach (var gate in initialGates)
+            {
+                if (possibleChange.Contains(gate.Output))
+                {
+                    possibleChange.Add(gate.InputLeft);
+                    possibleChange.Add(gate.InputRight);
+                }
+            }
+        } while (possibleChange.Count != initialSize);
+
+        var gatesToSwapIndices = initialGates
+            .Index()
+            .ToList()
+            .Where(t => possibleChange.Contains(t.Item.Output))
+            .Select(t => t.Index)
+            .ToList();
+
+        // Try out all possible permutations of concerned outputs
+        List<string> changedOutputs = [];
+
+        for (var a = 0; a < gatesToSwapIndices.Count - 7; a++)
+        {
+            for (var b = a + 1; b < gatesToSwapIndices.Count - 6; b++)
+            {
+                for (var c = b + 1; c < gatesToSwapIndices.Count - 5; c++)
+                {
+                    for (var d = c + 1; d < gatesToSwapIndices.Count - 4; d++)
+                    {
+                        for (var e = d + 1; e < gatesToSwapIndices.Count - 3; e++)
+                        {
+                            for (var f = e + 1; f < gatesToSwapIndices.Count - 2; f++)
+                            {
+                                for (var g = f + 1; g < gatesToSwapIndices.Count - 1; g++)
+                                {
+                                    for (var h = g + 1; h < gatesToSwapIndices.Count; h++)
+                                    {
+                                        Console.WriteLine($"h: {h}");
+
+                                        ForAllPermutation([
+                                            gatesToSwapIndices[a],
+                                            gatesToSwapIndices[b],
+                                            gatesToSwapIndices[c],
+                                            gatesToSwapIndices[d],
+                                            gatesToSwapIndices[e],
+                                            gatesToSwapIndices[f],
+                                            gatesToSwapIndices[g],
+                                            gatesToSwapIndices[h]], permutations =>
+                                        {
+                                            if (CheckPermutations(permutations) is { } modifiedOutputs)
+                                            {
+                                                changedOutputs = modifiedOutputs;
+
+                                                return true;
+                                            }
+
+                                            return false;
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        var swappedOutputs = string.Join(',', changedOutputs.Order());
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Swapped outputs: [yellow]{swappedOutputs}[/][/]");
+        }
+
+        return;
+
+        List<string>? CheckPermutations(int[] permutations)
+        {
+            var gates = initialGates.ToArray();
+            var zGates = initialZGates.ToHashSet();
+            var signals = initialSignals.ToDictionary();
+
+            SwapOutput(ref gates[permutations[0]], ref gates[permutations[1]]);
+            SwapOutput(ref gates[permutations[2]], ref gates[permutations[3]]);
+            SwapOutput(ref gates[permutations[4]], ref gates[permutations[5]]);
+            SwapOutput(ref gates[permutations[6]], ref gates[permutations[7]]);
+
+            var zOutputValue = 0L;
+            while (zGates.Count > 0)
+            {
+                // Avoid locks when result is not reachable (infinite loop)
+                var resultsCount = signals.Count;
+
+                foreach (var (inputLeft, inputRight, output, logicOperator) in gates)
+                {
+                    if (signals.ContainsKey(output))
+                    {
+                        continue;
+                    }
+
+                    if (!signals.TryGetValue(inputLeft, out var inputLeftValue) ||
+                        !signals.TryGetValue(inputRight, out var inputRightValue))
+                    {
+                        continue;
+                    }
+
+                    var computed = Compute(inputLeftValue, inputRightValue, logicOperator);
+                    signals[output] = computed;
+
+                    if (output.StartsWith('z'))
+                    {
+                        zGates.Remove(output);
+
+                        zOutputValue += (long)computed << int.Parse(output[1..]);
+                    }
+                }
+
+                // No new signal value computed, it's an infinite loop
+                if (signals.Count == resultsCount)
+                {
+                    return null;
+                }
+            }
+
+            if (xInputValue + yInputValue == zOutputValue)
+            {
+                return permutations.Select(i => gates[i].Output).ToList();
+            }
+
+            return null;
+        }
+
+        void SwapOutput(ref LogicGate first, ref LogicGate second)
+        {
+            var temp = first.Output;
+
+            first = first with { Output = second.Output };
+            second = second with { Output = temp };
+        }
+    }
+
+    private int Compute(int inputLeftValue, int inputRightValue, Operator logicOperator) => logicOperator switch
+    {
+        Operator.And => inputLeftValue & inputRightValue,
+        Operator.Or => inputLeftValue | inputRightValue,
+        Operator.Xor => inputLeftValue ^ inputRightValue,
+        _ => throw new ArgumentOutOfRangeException(nameof(logicOperator), logicOperator, null)
+    };
+
+    private (Dictionary<string, int> Signals, List<LogicGate> Gates, HashSet<string> ZGates) ParseInput()
+    {
+        var readingSignals = true;
+
+        var signals = new Dictionary<string, int>();
+        var gates = new List<LogicGate>();
+        var zGates = new HashSet<string>();
+
+        foreach (var line in Input.AsSpan().EnumerateLines())
+        {
+            if (line.IsWhiteSpace())
+            {
+                readingSignals = false;
+
+                continue;
+            }
+
+            if (readingSignals)
+            {
+                var signalName = line[..line.IndexOf(':')];
+                var signalValue = int.Parse(line[(line.IndexOf(':') + 2)..]);
+
+                signals[signalName.ToString()] = signalValue;
+            }
+            else
+            {
+                var split = line.Split(' ');
+                split.MoveNext();
+
+                var inputLeft = line[split.Current];
+                split.MoveNext();
+
+                var logicOperator = Enum.Parse<Operator>(line[split.Current], true);
+                split.MoveNext();
+
+                var inputRight = line[split.Current];
+                split.MoveNext();
+                split.MoveNext();
+
+                var output = line[split.Current];
+
+                gates.Add(new LogicGate(inputLeft.ToString(), inputRight.ToString(), output.ToString(), logicOperator));
+
+                if (output.StartsWith('z'))
+                {
+                    zGates.Add(output.ToString());
+                }
+            }
+        }
+
+        return (signals, gates, zGates);
+    }
+
+    private record LogicGate(string InputLeft, string InputRight, string Output, Operator LogicOperator);
+
+    private enum Operator
+    {
+        And,
+        Or,
+        Xor
+    }
+
+    // Source: https://stackoverflow.com/a/36634935
+
+    /// <summary>
+    /// Heap's algorithm to find all permutations. Non recursive, more efficient.
+    /// </summary>
+    /// <param name="items">Items to permute in each possible ways</param>
+    /// <param name="funcExecuteAndTellIfShouldStop"></param>
+    /// <returns>Return true if cancelled</returns>
+    private static bool ForAllPermutation<T>(T[] items, Func<T[], bool> funcExecuteAndTellIfShouldStop)
+    {
+        int countOfItem = items.Length;
+
+        if (countOfItem <= 1)
+        {
+            return funcExecuteAndTellIfShouldStop(items);
+        }
+
+        var indexes = new int[countOfItem];
+
+        // Unnecessary. Thanks to NetManage for the advise
+        // for (int i = 0; i < countOfItem; i++)
+        // {
+        //     indexes[i] = 0;
+        // }
+
+        if (funcExecuteAndTellIfShouldStop(items))
+        {
+            return true;
+        }
+
+        for (int i = 1; i < countOfItem;)
+        {
+            if (indexes[i] < i)
+            {
+                // On the web there is an implementation with a multiplication which should be less efficient.
+                if ((i & 1) == 1) // if (i % 2 == 1)  ... more efficient ??? At least the same.
+                {
+                    Swap(ref items[i], ref items[indexes[i]]);
+                }
+                else
+                {
+                    Swap(ref items[i], ref items[0]);
+                }
+
+                if (funcExecuteAndTellIfShouldStop(items))
+                {
+                    return true;
+                }
+
+                indexes[i]++;
+                i = 1;
+            }
+            else
+            {
+                indexes[i++] = 0;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Swap 2 elements of same type
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void Swap<T>(ref T a, ref T b)
+    {
+        T temp = a;
+        a = b;
+        b = temp;
+    }
+}

Days/Day25.cs

@@ -0,0 +1,111 @@
+using System.Collections.Frozen;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics.X86;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.VisualBasic;
+using Spectre.Console;
+
+namespace AdventOfCode.Days;
+
+public class Day25 : Day
+{
+    public override int Number => 25;
+    public override string Name => "Code Chronicle";
+
+    public override void RunPart1(bool display = true)
+    {
+        var (locks, keys) = ParseInput();
+
+        var workingPairs = 0;
+
+        foreach (var lockToTest in locks)
+        {
+            foreach (var key in keys)
+            {
+                if (lockToTest.Height1 + key.Height1 < 6 &&
+                    lockToTest.Height2 + key.Height2 < 6 &&
+                    lockToTest.Height3 + key.Height3 < 6 &&
+                    lockToTest.Height4 + key.Height4 < 6 &&
+                    lockToTest.Height5 + key.Height5 < 6)
+                {
+                    workingPairs++;
+                }
+            }
+        }
+
+        if (display)
+        {
+            AnsiConsole.MarkupLine($"[green]Amont of unique key/lock pairs that fit: [yellow]{workingPairs}[/][/]");
+        }
+    }
+
+    public override void RunPart2(bool display = true)
+    {
+
+    }
+
+    private (List<Lock> Locks, List<Key> Keys) ParseInput()
+    {
+        var locks = new List<Lock>();
+        var keys = new List<Key>();
+
+        Span<int> itemHeights = stackalloc int[5];
+
+        var input = Input.AsSpan();
+        foreach (var itemRange in input.Split($"{Environment.NewLine}{Environment.NewLine}"))
+        {
+            var item = input[itemRange];
+            var lines = item.EnumerateLines();
+
+            var isKey = false;
+
+            // Reset item heights
+            itemHeights[0] = -1;
+            itemHeights[1] = -1;
+            itemHeights[2] = -1;
+            itemHeights[3] = -1;
+            itemHeights[4] = -1;
+
+            for (var height = 0; height <= 6; height++)
+            {
+                lines.MoveNext();
+                var line = lines.Current;
+
+                if (height is 0)
+                {
+                    isKey = line is ".....";
+
+                    continue;
+                }
+
+                for (var i = 0; i < 5; i++)
+                {
+                    if (isKey && line[i] is '#' && itemHeights[i] is -1)
+                    {
+                        itemHeights[i] = 6 - height;
+                    }
+                    else if (!isKey && line[i] is '.' && itemHeights[i] is -1)
+                    {
+                        itemHeights[i] = height - 1;
+                    }
+                }
+            }
+
+            if (isKey)
+            {
+                keys.Add(new Key(itemHeights[0], itemHeights[1], itemHeights[2], itemHeights[3], itemHeights[4]));
+            }
+            else
+            {
+                locks.Add(new Lock(itemHeights[0], itemHeights[1], itemHeights[2], itemHeights[3], itemHeights[4]));
+            }
+        }
+
+        return (locks, keys);
+    }
+
+    private readonly record struct Lock(int Height1, int Height2, int Height3, int Height4, int Height5);
+    private readonly record struct Key(int Height1, int Height2, int Height3, int Height4, int Height5);
+}

Inputs/Day16.txt

@@ -0,0 +1,141 @@
+#############################################################################################################################################
+#.........#...........#.................#.......#.............#.....#.#...#...........#.....#.....#...#.......#.....#...........#.......#..E#
+#.#######.#.#.#######.###.#########.###.#######.#.#.#.###.#.#.###.#.#.#.#.#.#####.#.###.#.#.#.#.#.#.#.#.#.#.#.#.###.#.#####.###.#.#####.###.#
+#.#.....#.#.#.#.....#...............#.#.#.....#...#...#.#.#.......#...#.#.#.....#.#.#...#.....#.#.#.#...#.#.....#.#.........................#
+#.#.###.#.#.#.###.#######.###########.#.#.###.#.#######.#.#.#########.#.#.#.#####.###.#####.###.#.#.#####.#######.#.#.#.#.#.#.#.###.#.#.#.###
+#...#.#.#...#...#...#.....#...........#.#...#.#.#.......#.#.........#.#.#.#.#.....#...#.........#.#.....#.......#.#.#.#.....#.......#...#...#
+#.#.#.#.#######.###.#.###.#.#########.#.###.#.#.#####.#.#.#.###.###.###.#.#.#.#.#.#.###.###.#####.#.#######.###.#.#.#####.#.#########.###.#.#
+#.#...#.......#...#...#...#...#.#.....#...#.#.#.....#.#.#...#...#...#...#...#...#.#.#...#.........#.#.....#.#...#.#...#...#...#.......#.....#
+#.#.#.#######.###.#####.#.###.#.#.#######.#.#.#####.###.###.#.###.###.#########.###.#.###.#.#######.#.###.###.###.###.#.#.#.#.#######.#.#.###
+#.#.#.......#.#.#.#...#.#.......#.......#.....#...#...#...#...#.#.....#...#.....#...#.#.....#...#...#...#...........#.#.#.#.#.#.....#...#...#
+#.#.###.#####.#.#.#.#.#.#.#########.###.#####.###.###.#.#.#####.#######.###.#####.###.#####.#.#.#######.#.#.#####.###.#.#.#.#.#.###.###.#.#.#
+#...#.#.........#...#.#...........#...#.....#...#...#...#.#.........#.....#.#.....#.#.....#.#.#.......#.#...#...#.......#.#.#...#.#.#.....#.#
+#.#.#.###############.#.#.#.#####.#####.###.###.#.#.#####.#######.#.#.###.#.#.#####.#####.#.#.#######.#.###.#.#.###.#####.#.#.###.#.#.#.#.#.#
+#.#...#.....#.#...#...#.#...#...#.....#...............................#...#.............#...#...#.................#.#...#...#.....#.....#...#
+#.#.#.###.#.#.#.#.#.#####.###.#.#####.#.#.#.###.###.#######.#.#####.###.#.#########.#####.#.###.#####.###.###.###.#.#.#.#.#.###########.#.#.#
+#.#.#...#.#.....#...#.....#...#.#...#.#...#.#...#...#.......#.#...#.....#...#.............#...#.....#.#...#...#...#.#.....#.......#.......#.#
+#.#.###.#.###.#.#####.#####.###.#.###.#####.#.###.#.#.#######.#.#.###.#######.#############.#.#.###.#.#.#.#.###.#.###.###.#.#####.#.###.#####
+#...#.#...#...#...#...#.....#...#.#...#...#.#.#...#.#.#.......#.#.#...#.......#.....#.........#...#.#...#.#.#.#.#.#...#.#.........#...#.#...#
+#.###.#####.#####.#.#######.#.#.#.#.###.#.#.#.###.###.#.#####.#.###.#.#.#######.###.#.###########.#.#######.#.#.#.#.###.#.#####.#.###.#.#.#.#
+#...#.......#...#.........#.#.....#.....#.#.#.#...#...#.#...#.#.....#...#.....#.#...#.#...#.....#.#.......#.#.#.#.#.....#.#.....#.#...#...#.#
+#.#.#.#######.###########.#.#####.#######.#.#.#.###.#####.#.#.#######.#.#.#.###.#.#.#.#.#.#.###.#.#.#####.#.#.#.#######.#.#.###.#.#.###.#.#.#
+#.#...........#...#.....#.#...#.......#...#...#...#.#.....#...#.......#...#.....#.#.#.....#.#.#...#...#...#...........#.#...#...#.#.......#.#
+#.###########.#.#.###.###.###.#########.#.#.###.#.#.#.###.#####.#######.#########.#####.#.#.#.#######.#.###.#####.###.#.#####.#.#.#.###.#.#.#
+#.......#.....#.#.............#.........#.#.#...#.#.#...#.#...#.....#.#.#...#...#.......#.#...#.....#.#.....#...#...#.....#...#...#.........#
+#.#####.#######.###.#.#######.#.#########.#.#.###.#.###.#.#.#.#.###.#.#.#.###.#.###.#.#.#.###.###.#.#.#######.#.#######.#.#.###.#######.#.#.#
+#...#.#...#.....#...#.....#.#.#...#...#...#.....#.......#.#.#.#...#.#...#.#...#...#.#...#...#.....#.......#...#.......#.....#.#.#.......#.#.#
+###.#.###.#.#####.#####.#.#.#.###.#.#.#.#######.#.#########.#.#.###.#.###.#.#####.###.#####.#############.#.#######.#.#####.#.#.#######.#.#.#
+#...#.......#...#...#...#.#.....#...#.#.....#...#.#.........#.#.#...#.#...#.#.........#.....#...........#.#.#.#.............#.#.....#.....#.#
+#.#.#####.#.###.###.#.###.#######.#.#.###.#.#.###.#.###.#####.#.#.###.###.#.###########.#####.#########.###.#.#.#############.#.###.#.#.#.#.#
+#.#.....#.........#...#.#.......#.#.#...#.#.#.#...#.....#.....#.#...#.....#...#.........#.....#.......#.....#...............#...#.#.#.....#.#
+#.#.###.#.###.#########.#######.#.#.###.###.#.###.#####.#.#########.###.#.###.#.###########.###.#.#######.#.#####.#.#.#####.#.#.#.#.#.#.#.#.#
+#...#...#...#.#...............#.#...#.#.#...#...#.....#.#.#.......#.#.......#.#...#.........#...#.#.......#.......#.#.#.#...#.#...#.#.#...#.#
+#####.###.#.###.#########.###.#.###.#.#.#.#####.#######.#.#.#####.#.#######.#.###.#####.#####.#####.#############.###.#.#.###.#.###.###.#.#.#
+#.....#...#.....#...#...#...#.#.#...#.#.#...............#...#...#.#.....#...#...#.........#...#.....#.......#.........#.#...#.........#...#.#
+#.#####.#.#######.#.###.###.#.#.#.###.#.#####.###############.###.#.###.###.#.#.#####.#.#.#.#.#.#####.#.#.#.#.###.#.###.###.###.#####.###.###
+#...#.#.......#...#.....#...#.#.#.#...#.#.............#.......#...#...#...#.#.#.#.#...#.#.#.#.#.#.....#...#...#...#.....#.#.................#
+###.#.###.###.#.#######.#.#.###.#.#.###.#.#####.#######.#.#####.###.###.#.#.#.#.#.#.###.#.#.#.#.###.#####.#####.#######.#.#########.###.###.#
+#...#.#.....#.#.#.......#.#.#...#...#...#.#.....#.......#...#...#.....#.#.#.#.....#.....#.#...#...#.....#...#...#...#...#...#.....#.#.......#
+#.###.#.#.#.#.#.#.#######.#.#.###.###.###.#.#####.#####.###.#.###.###.###.###.###.###.###.#.#.###.###.#####.#.###.#.#.###.#.#.#.###.#########
+#.........#.#...#.#.....#.#.#.#...#...#...#.#.....#.....#.#...#.#...#.....#...#.....#.....#.#...#...#.#.....#...#.#.#.#...#.#.#...#...#.....#
+#.#.#.#.#.#######.###.###.###.#####.###.#####.#####.#.#.#.#####.#.#.#######.###############.#.#.###.###.#######.#.#.#.#.###.#.###.###.#.###.#
+#.#.#...#.#.....#...#.#...#...#.....#.......#.....#...#.#.........#...#.................#...#.#...#...#.#...#.....#.#.#.#.#.#.#...#.#...#...#
+#.#.#####.#.#.#####.#.#.###.###.#####.#####.#####.#.###.#.###########.#.#####.#######.#.#####.###.###.#.#.#.#######.#.#.#.#.###.#.#.#####.#.#
+#.#.....#.#.#.....#.#.#.........#...#.#...#.....#...#.#.#.........#...#.#.......#...#.#.......#.#...#.#...#.#...#...#...#.#.....#.......#.#.#
+#.#####.#.#.###.###.#.#####.###.#.###.#.#######.#####.#.###########.###.###.###.#.#.#.#########.#.###.#.###.#.#.#.#######.#############.#.#.#
+#...#.#.#.#.#.#.#...#.#...#.....#...#.#.......#.#.....#.#...........#.#...#.#...#.#.#...#...#.....#...#...#...#.#.#.............#...#...#...#
+###.#.#.#.#.#.#.#.###.#.#.#########.#.###.###.#.#.###.#.#.#######.###.###.#.#.###.#.#.#.#.#.###.###.#########.#.###.#.#########.#.#.#.#####.#
+#.....#.#.#.#.#.#.....#.#...#.....#.#.#...#...#.....#.#...#.......#.........#.....#...#.#.#...#.#...#.......#.#.....#.#.......#...#.#.....#.#
+#.#####.#.#.#.#.#####.#.###.#.###.#.#.#.###.#########.#####.#####.#.###############.###.#.###.###.###.#####.#.#######.###.#########.#####.#.#
+#.#.....#.#...#.......#...#.#.#...........#.#...........#...#.#...#.#.#.......#...#.#...#.#.#.....#.....#.#.#.#...#...#...#.........#.....#.#
+#.#.#####.###.###########.#.#.#######.###.###.#.#########.###.#.###.#.#.#####.#.#.#.#.###.#.###########.#.#.#.#.#.#.###.#.#.#######.#.#####.#
+#.#...#.....#...#.........#.#.......#.....#...#.#.........#...#.......#.#...#.#.#...#.....#.........#...#...#.#.#...#...#.#.#.....#.#.#...#.#
+#.###.#####.#.###.#########.###.###.#####.#.###.#.#########.#.#######.#.#.###.#####.#.#.#.#####.###.#.###.#####.#####.#.###.#.###.###.###.#.#
+#...#.....#.......#.......#.#.....#.....#.#.#...#...#.......#.........#.#.....#...#.#.#.....#...#...#...#.#.....#...#.#...#.#.#.#.........#.#
+#.#####.#.#.#.#.###.#####.#.#.###.###.###.#.#######.#.#.#######.#####.#.#.#####.#.#.#.#####.#.###.###.#.#.###.###.###.###.#.#.#.###########.#
+#.#...#.#.#.#.#...#.#.....#.#.#.#...#.....#.......#.#...........#.....#.#.#.....#.#.#...#.#...#.#...#.#.#.....#.....#.#...#.#.#...#...#...#.#
+###.#.###.#.#.###.#.#.#####.#.#.###.#.###########.#.#######.#.###.###.#.#.#.#####.###.#.#.#####.###.###.###.#####.#.#.#.#.#.#.#.###.#.#.#.#.#
+#...#.....#.#...#...#...#.#...#.....#.........#.#.#.........#.#...#.#.#.#...#...#...#.#...#.....#.#...#.#.......#.#.#...#...#.......#.#.#.#.#
+#.#########.###.###.###.#.#######.#.#########.#.#.###.#.#####.###.#.#.#.#####.#####.#.###.#.#.#.#.###.#.#####.#.###.###.###.#.#.#.###.#.#.#.#
+#.....#.......#.#.....#...#.......#...#...#.....#...#.#.#...#...#.#.........#...#.....#...#.#.#.....#.#.#.....#...#.....#.......#.#.....#...#
+#####.#.###.###.#.###.#.#.###.###.###.#.#.#.#####.#.#.#.###.###.#.#######.#.#.#.#.#########.#.#######.#.#.#######.#######.#######.#########.#
+#.....#.#.#...#.#...#.........#.....#.#.#.#.#...#.#.....#...#.....#.....#.#...#.#...#...#...#.........#.#.#.....#.#.......#.#...#.#...#...#.#
+#.#####.#.###.#.#.#.###########.#####.#.#.#.#.#.#####.###.###.#####.###.#.###.#.#.###.#.#.#####.#######.#.#.#.#.#.#.#.#####.#.#.#.#.#.#.#.#.#
+#...#.......#.#.#.#.......#.....#.....#.#...#.#.#.....#.......#...#.....#...#.#...#...#.....#.........#...#.#.#.#...#.......#.#...#.#...#.#.#
+#.#.#####.###.#.#######.###.###.#.###########.#.#.###.#.#####.#.#.###.#.###.#.#####.###.###.#.#.#####.#.###.#.#.#######.###.#.#####.#####.###
+#.#...#.#.#...#...#...#...#.......#...........#.....#.#.#...#.#.#.....#.#...#.#.......#...#.#.#...#...#...#.#.#...#...#...#.................#
+#.###.#.#.#.#####.#.#.###.###.#.###.#####.###########.###.#.###.#######.#.#.###.#########.#.###.#.#######.#.#.###.#.#.#####.###########.###.#
+#.#...#...#.....#.#.#.#.....#.#.#...#.....#.....#...#...#.#.....#.....#...#.#...#...#.........#.#.#.....#.#.#...#.#.#.......#...........#...#
+#.#.#.#########.#.#.#.#.###.#.#.#.#####.###.###.#.#.###.#.#####.#.###.#.#.#.#.###.#.#.#######.#.#.#.###.#.#.###.#.#.###.###.#####.#.#####.#.#
+#.#.#.#.......#.....#...#.#.#.#.........#...#.#...#.....#...#...#...#...#.#.#...#.#.#.........#.#.....#.#.#.#...#.#.......#.......#.#.....#.#
+#.#.#.#.#####.###########.#.#.#########.#.###.#########.#.#.#.#.#.#.#.#.#.#####.###.#######.###########.#.###.###.#######.#########.#.#####.#
+#.#.......#...#.........#...#...#.#...#.#...#.#...........#...#.#.#.#.#.#.......#.......#...............#.....#...#.....#.#.............#...#
+#####.###.#.#.#.#######.#.###.#.#.#.#.#####.#.#.###.#######.#.#.###.###.#.#######.#####.###.#.###.#####.#######.###.###.#.#####.#######.#####
+#.....#.....#.#.....#...#.....#.#.#.#.......#...#.......#.....#...#.............#.....#.....#...#.#...#.#.....#...#...#.#.#...#.#...........#
+#.###.#.#.#########.#.#######.#.#.#.#############.#####.#.###.###.#############.#.###.#######.#.#.#.#.#.#.###.###.###.#.#.#.#.###.#.#.#.#.#.#
+#.#.#.#.............#.......#.#...#...............#...#...#.....#.#.........#...#...#.......#.#.#...#.....#.....#...#.#...#.#...#.#.#...#.#.#
+#.#.#.###.#################.#.###.###.#.#############.#####.###.#.#.#######.#.#############.#.#.###############.###.#.#####.###.#.#.###.#.#.#
+#.#...#.....................#...#...#.#.#.....#.......#.....#.#.#...#.....#.#.#.....#.......#.#...#...........#...#.#...#...#.#.#.#...#...#.#
+#.#.#.#.#.#######.###############.###.#.###.#.#####.#.#.#####.#.#####.#.###.#.###.#.#.#######.###.#.#########.#.###.#.#.#.###.#.#.###.#.###.#
+#.#.....#...#...#.#.......#.......#...#.#...#.#.....#.#.#...#...#...........#...#.#...#.......#...#.#.......#.#...#.#.#.#...#...#.#.#.......#
+#.###.#.#.#.###.#.#.#####.#.#######.###.#.###.#.#####.#.#.#.#####.#############.#.#####.###.###.#.#.###.###.#.#.#.#.###.#.#.#.###.#.###.###.#
+#.#...#.#.#.......#...#.#...#.....#.....#...#...#...#.#...#.......#.......#...#.#.#...#.#...#.#.#.#...#...#.#...#...#.....#.#.....#.#.......#
+#.#.#.###.#.#.###.###.#.#####.###.#########.#####.###.#############.#####.###.#.#.#.#.#.#.#.#.#.#.###.###.#.#########.#.#.#.#######.#.#.###.#
+#...#...#...#...#...#.#...#.....#.#.......#.....#.....#.....#.....#...#.#.....#.#...#.#.#.#.#.#.#...#.#...#.........#.#...#.#.....#...#.....#
+#.###.#.###.###.#####.###.#.###.#.#.###.#.#.###.#.#######.#.#.#.###.#.#.###.###.#.###.#.#.#.#.#.#####.#####.#####.#.#.#.###.#.#.###.###.#####
+#.#...#.....#...#.....#...#.#.#.#.#.#...#.#...#.#.#.......#.#.#.......#.....#...#.#.#.#.#.#...#.#...#.....#.....#.#.#.#.#...#.#.....#.......#
+###.#.#######.#.#.#####.###.#.#.###.#.###.#####.#.#####.#####.#######.#######.###.#.#.#.#.###.#.#.#.#####.###.###.#.#.#.###.#.#######.#.###.#
+#...#...#.....#.#.....#.#.....#.....#.#.........#...#...#.....#.....#.#.....#.#.....#.....#...#...#.....#...#.#.......#...#.....#.....#...#.#
+#.###.#.#.#####.#####.#.#.###.#######.#.###########.#.###.#####.#.###.#.###.#.#.#################.###.#.###.#.#.#####.###.#####.#.#####.#.#.#
+#.#.......#.#.......#...........#.#...#...#.......#.#...#.......#.....#.#.#...#.#.#.............#.#.#.#.#.#.#.#...#.#.#.#...#.#.#.....#...#.#
+#.###.#####.#.#####.#.#########.#.#.###.#.#.#######.###.#.#.#####.#####.#.#####.#.#.###.#######.#.#.#.#.#.#.#.###.#.#.#.###.#.#.#####.#.###.#
+#.#...#...#...#.....#...#...#.....#.....#.#...#.....#...#...#.....#.....#.....#.#.#...#.....#...#...#.#...#.#.#...#.......#.#.#...#...#...#.#
+#.#.#.#.###.###.#.#.###.#.#.#########.###.###.#.#####.###.###.#.###.#####.#####.#.###.#.#.#.#.#######.###.#.###.###.#######.#.###.###.###.#.#
+#...#.#.....#.#.#.#.#.#...#.....#...#.#.#...#...#.....#...#...#.....#.#.........#...#.#.#.#.#.....#...#.#.#.....#...#.....#.#...#...#.#...#.#
+#####.#.#####.#.#.#.#.#####.###.#.#.#.#.###.#.###.#####.###.###.#####.#.#########.#.#.#.#.#.#####.#.###.#.#######.###.###.#.#.#####.#.#.###.#
+#.....#.#.....#.#.#.......#...#.#.#.#...#...#.....#...#...#.....#.#...#.#.........#.#.#.#.#...#.#.#...#.........#...#.#.....#.#.....#.#...#.#
+#.#.###.#.#####.#.#####.###.#.#.#.#.###.#.#.#######.#.###.#######.#.#.#.#.#.#######.#.#.#.###.#.#.###.#############.#.#######.#.#######.#.###
+#.....#...#.....#.#.....#...#...#.#.#.....#.........#.....#...#.....#.#.#.#.#...#...#.#.#.#.#.#.#.#...#.............#.....#.......#...#.#...#
+#.#.#.#####.#####.#######.#######.#.#.###.###.#############.#.#.#####.#.#.###.#.#.###.###.#.#.#.#.#.#.#.###############.#.#######.#.#.###.#.#
+#...#.#.....#.#...#.......#.......#...#.#.#...#.#...#.......#.#.#...#...#.#...#.#...#...#.......#...#.#...#...........#.#...#...#...#...#.#.#
+###.#.#.#####.#.###.#######.###.#######.#.#.###.#.#.#.#.#####.#.###.#####.#.###.#######.#.#######.#######.#.#########.###.#.#.#.#######.###.#
+#.....#...#...#.#...#.....#.#.#.....#.....#.#.....#...#.#.....#...........#.#.#...#.....#.#.......#.......#...#.....#.....#...........#.....#
+#.#.#####.###.#.#.###.###.#.#.#####.#.#####.#.#########.#.#########.#.#.###.#.#.#.#.#.#.#.#.#######.#########.#####.###.###.#####.#.#.#####.#
+#.#.....#.....#.#.#...#.#.#...#.#...#.#.....#.#.........#...#.........#.#...#...#...#...#...#...#...#...#...#...#.....#...#.#...#.#.#.....#.#
+#.#.###.#####.#.#.#.###.#.###.#.#.#.###.#####.#.#.#.#######.###########.#.#####.###.#.#######.#.#.###.#.#.#.###.#.###.###.#.#.#.#.#.###.###.#
+#...#.............#...#...#...#...#.#...#.....#.#...#.....#.......#.....#.#.......#.#.......#.#.#.#...#.#.#...#.#...#.#...#.#.#...#...#.....#
+#.#.#.#####.#.#######.#.#####.#.#.#.#.#########.#######.#.#######.#.###.#.###.#.###.#.#####.#.#.#.#.###.#.#.###.#.#.#.#.###.#.#############.#
+#...#.#.....#...#.....#.....#...#.#.#.....#.....#.......#.#.....#.#.#...#...#.#.#...#.#...#...#...#.#.....#.#...#...#.#...#.#...#...#.....#.#
+#.#.#.#.#######.#.#########.#####.#.#####.#.#.###.###.#####.###.#.#.#.#.###.#.#.#.###.#.#.#########.###.###.#.###.#.#####.#####.#.#.#.###.#.#
+#.#...#.#.....#.#.......#.#.#.....#.#.......#.#.......#.....#.....#.#.#.#...#.#.#.#...#.#.#.......#.......#.#.#...#.......#.....#.#...#...#.#
+#.#.#.###.#.#.#.#######.#.#.#.#.#####.#.#####.#.#.###.#.#####.###.#.#.#.#.###.###.#.#####.#.#.###.###.#.#.#.#.#.###########.#####.#####.#####
+#.#...#...#.#.#.........#.....#.#.....#.........#...#.#.#...#...#.#.#.#...#...#...#.....#...#.#...#...#.#...#.#.#...........................#
+###.#.#.###.#########.#.#######.#.#################.###.#.#####.#.#.#.#####.###.#######.#####.#.###.#.#.#.###.#.#######.#.#################.#
+#.....#...#.......#...#.........#.#.#.............#.....#.....#.....#.#...#.....#.#.....#.........#.#.#.#.....#.....#...#.#...............#.#
+#.#.#.###.#######.#.#####.###.###.#.#.###.#.###############.#.#######.#.#.#####.#.#.#####.#######.#.###.###########.#.#.###.#############.#.#
+#.........#.....#.#.#...#...#.#.#.#.#.#...#.#...........#...#.........#.#.....#...#.....#.#.....#.#...#.#.#.......#.#.#...#...#...#.....#...#
+###.#.###.#.###.#.#.#.#.#.#.#.#.#.#.#.#.#####.###.#####.#.#####.#######.#####.#########.#.#.#.#.#.###.#.#.#.###.#.#.#.###.###.###.#.###.###.#
+#...........#.#.#...#.#.#.#.#...#.#...#.....#.#...#...#.#.#.....#...........#.............#.#.........#.#.#...#.#.#...#.#.....#...#.#.#...#.#
+#.###.#.#.###.#.#.#.#.#.###.#.###.#.#######.#.#.###.#.#.#.#.#####.#########.#####.#########.#########.#.#.###.#.#######.#######.###.#.###.#.#
+#.#.......#.....#...#.#.....#.#...#...#...#...#...#.#.#...#...#...#...#...#.#...#.#.....#...#.....#...#.#.#...#.......#...#.....#...#.#...#.#
+#.#.#.#.#.#.#########.#######.#.#####.#.#.#######.#.#.###.#####.###.#.#.#.###.#.###.###.#.###.###.#####.#.#.#######.#.#.#.#.###.#.###.#.###.#
+#.#.....#...#.........#.....#.#...#.#...#.......#.#.#.#...#...#.#...#...#.#.........#...#...#...#.#.....#.#...#...#.#.#.#.#.#...#.....#.....#
+#.#####.#.###.###.#####.###.#.###.#.###.#.#######.#.#.#####.#.#.#.#######.#.#.#######.#####.###.#.#.###.#.###.#.#.#.#.###.#.#.###.###.#######
+#.#...#...#.....#.#.#.....#.#...#.#.....#.......#...#.#.....#.#.#...#.......#.......#...#.....#.#...#.........#.#.#.#...#.#.#.....#.....#...#
+#.###.#.#.#.#####.#.#.#####.###.#.#.#####.#.###.#####.#.#####.#.###.#####.###.#####.###.#######.#####.###.#####.#.#.###.#.#.#######.###.###.#
+#.....#.#...#.....#...#...#.....#.#.....#.#.............#...#.....#.#...#.#...#...#...#.....#...#...#.#...#.....#.#...#...#.#.....#.#.#.#...#
+#####.#.#.###.#####.###.#.#.#####.#####.###.###.#####.###.#########.#.#.#.#.#.###.#.#######.#.###.#.#.#.#.###.###.#.#.###.#.#.#.#.#.#.#.#.#.#
+#.#...........#.....#...#.#.#...#.#...#.#...#.........................#.#.........#.......#.#...#.#.#...#.#...#.....#.#...#.#.#.#...#.#.#.#.#
+#.#.#######.#.#.#####.###.#.#.#.#.#.#.#.#.#.#.###.#.#####.#.#########.#.#.#############.#.#.###.#.#.#####.#.#.#####.#.#.###.###.#####.#.#.###
+#.......................#.#...#.#...#.#...#.......#...#...#.........#.#.#.....#...#...#.#.#.....#.#...#.#.#...#.......#...#.....#...#...#...#
+#.#####.#####.#########.#.###.#.#####.###.#.#.#######.#####.#######.#.#.#.###.#.#.#.#.#.#.#.#####.###.#.#.###.#.###.#####.#######.#.#.###.#.#
+#.#.....#...#.#.......#.#...#.......#.#...#.#...#...#.............#...#...#.#...#...#.#.#...#...#...................#.....#.......#.#.#...#.#
+###.#.###.#.#.#.#####.#.###.#####.###.#.###.#.#.#.#.#####.#######.#######.#.#########.#.###.#.#.#.#.#####.#.#######.###.###.#####.###.#.###.#
+#...#.....#.#.#...#...#.#.#.#...#.#...#...#...#.#.#.....#.#...............#.........#.#...#...#...#.....#.#.......#.......#.#...#.....#.#...#
+#.#########.#.###.#.###.#.#.###.#.#.#####.###.#.#.###.###.#.#############.#######.###.###.#############.#.#.#.###.#.###.#.#.#.#.#######.#.###
+#.....#.........#.#...#...................#.....#...#...#.#...#.........#.......#...#.#...#.....#...#...#.#.#.#.#.......#...#.#.#...#...#...#
+#.###.#.#########.###.###.###.#.#####.#.#.#.#.#####.###.#.#####.#######.#.#####.###.#.#.###.###.###.#.###.###.#.###.###.#####.###.#.#.#####.#
+#...#.#.....#.....#...#...#...#...#...#...#...#.#...#.#...#.....#.....#...#...#.....#.#.......................#.....#...#.........#.........#
+#.#.#.#######.#####.###.###.#######.#########.#.#.###.#####.#####.#######.#.#.#######.#######.###.#.#####.#.###.###.#.#.###################.#
+#S..#.............#.......#...................#.............#...............#.........#...........#.........#...............................#
+#############################################################################################################################################

Inputs/Day17.txt

@@ -0,0 +1,5 @@
+Register A: 44348299
+Register B: 0
+Register C: 0
+
+Program: 2,4,1,5,7,5,1,6,0,3,4,2,5,5,3,0

Inputs/Day19.txt

@@ -0,0 +1,402 @@
+wugw, wrrbgr, rbgr, bgbrb, wuwb, bug, wubur, uwbuwbug, wruu, rbbr, wbgrrg, uuwr, bub, brbggggr, brgguw, gwwuu, uwrbggw, wuwrrr, wbuurww, wwwuwru, gubgr, gubu, ug, ubu, gggrgr, wg, wrgbggu, uwgwubw, bgrgb, uu, gbug, gwuwgr, bgwg, rurgb, rr, ubw, wrr, rggw, ubuu, ubr, ugrr, wrbwrruw, uw, ruggrb, urwwurg, gwr, rurwb, bu, uuu, bbuwb, urbu, ugb, uruub, gwgrrw, wbbw, rwgr, wur, bwbu, bbg, wrbugw, brgr, uurrwg, guruu, uurrrbw, bwwbrguw, gbbgu, bgg, bbwwgbw, rww, uurrr, bgubwb, wwgr, gw, wrgub, wgrg, rugwbb, bgwbuguw, brg, ggbw, bgbubb, wwgu, gwgb, grur, gubw, wbruug, rg, brubbgw, uuugr, rru, brbr, rwbuuu, ubuw, rgru, rwrwgb, wub, rwbu, bwwrr, bwrg, uggbur, gwb, gbugwb, br, rbwu, urubg, uuw, rbb, rgrwu, bguuw, w, www, wurgb, rwwu, rwg, uww, gbwurubb, uuugb, rbrurw, gggbwu, rbrwrgwr, bw, uwrw, bugw, brgguugb, brubw, bbrb, bru, urgr, urwu, bwbb, bur, rwrr, wrrbu, guu, ggugwuw, rwrurb, wbur, gbu, bbb, ur, brw, wrwbb, ugbuwgug, rrugbbru, wwggbw, gwgwgur, rgw, rwwr, wrg, wugrwru, ggwr, ggr, wug, ugu, gbbw, wgww, gwwwuw, gbr, rbwwru, bbru, ruw, gbrgw, gug, bwbuwrb, uwg, rbww, bbbrb, ub, rgrbr, ubg, wugwub, bgr, ru, bwr, bwbug, rgr, wwugr, grg, rwu, wbgg, rgwu, ubugubr, buggur, wwb, rub, wugbb, uubb, uwb, wbb, uwgbw, rubrg, rwubgu, wgwbb, bubrbrww, bg, wwrggu, gr, gggr, ggb, wuuuu, bggwb, ubgrwbr, rgubwu, rwr, gbww, wgbub, ubrb, ruu, rgg, wgrwurrw, ubwggr, uubr, wrwrbrr, ruguw, bwu, guwrug, bgggw, urubr, rruruuw, gur, wrgru, wb, rgwwg, rrguu, wwwugg, rgbg, uwwgg, urr, gwu, ruwb, buwbgur, bbwugb, bubu, rwurwg, wgrb, rrw, uwgwr, ugwu, rgrurg, ww, uwgrrrgb, wrub, bgb, grr, bgwbru, wr, brrbg, rurur, wgbbbur, brwgg, bwgwbw, uuurg, rw, uuwguu, guw, bwg, bwrrwrr, ugr, rbwrg, rwb, urw, uubg, bbwrugr, bgw, brb, rb, rbr, ubbwurb, gbw, buu, wgg, wbw, ugguubw, rurbr, rrwbuur, ubwuwr, urg, wwu, wrguwb, bbgbur, grb, gww, gb, buw, bwbg, grgb, bbu, rbw, rrbu, gruwbw, uur, wwbgr, bwbwu, bgug, uwu, wubbw, rgwr, rrgrr, gwg, bbbubu, wwgrbrw, wuuubb, gbg, uwbwbg, wgwbr, ububb, ubbb, rug, gwbbrb, ubrub, urb, ggrwrgg, rrg, wbr, uub, wbrwbb, ugg, wrgb, bbwu, grurwb, uwbr, ugug, grw, gru, rwgu, wrru, rwgggu, rrr, ugwb, rrrw, brr, buwb, rbwbrg, ugw, rwuuguw, bwgggwb, bugr, wggbrr, uwgrrbub, bgbuuwug, burrrbu, wubwuu, ubwur, ubgwb, uru, brrb, wgb, bwuwgbu, wwuwwbu, bgbbg, wwru, wgr, ggg, guwuu, brbg, gbrb, ugrg, wwgur, wbbu, rwug, gbb, wugr, wuur, ubwurrwg, gwruubgu, wrrw, wubwwg, gugur, urgwu, wrbu, wbg, grwb, ugrrrrb, grbg, ggbbu, gbru, wgw, ggug, ubuub, ggu, wuwrbugb, ugrrrr, gbbubrr, rbgbb, bwwbu, uwwu, wwgbbb, gbbu, b, brwgr, wrb, rwrrw, rubwugg, bbr, wwr, wu, bbgwgbb, rbg, rwwgbbu, bgu, wubuug, ubwww, uggr, rbbbw, rbwgwrbw, bbw, bbgr, rur, ubb, uurbg, wguwb, ubbrgug, wrwr, rwwugb, uwrubb, rrgbbru, bwb, gub, ggbu, wwg, bww, ruwrwg, gbwu, wuu, gbbur, wrubru, rgb, grugwbbw, r, rwww, rbbru, wbrrb, rwgub, ubbrr, wuw, uug, rgu, rggg, bb, g, wru, urgw, ggw, ugwwbrg, grrbw, rbu, bbgugrw, grguw
+
+urwrggwgbrrwggwuubrrwwugbgbubwbuuugwbguggubrgwwrubub
+wuwguurugggwbbruubbruwbruugwbguuwrwbrbugurbgugrggb
+wrbgrwbwbgrrguwbwuugruugrwbugrwuuuuurrugrgggugwuububwrwbg
+bbbrbwrrwrgrwubbwgbbrbwbruuuwuuwwubbwwgwuwgguurbg
+bguuubgbwggwgurubuubgurruggbgubwrbrrgbbgugbbugruurggwr
+uwbbgwbrwubrwuwwbrbubbuggbbbbrugbbrwrubwrg
+rgrrgruwrrrgwwgrrrrwbuuugrgbbrgbwwruggwrwr
+wgwwuuruuwrbwbuwwwwbrgurgrgrgruwbrbugbbwggg
+guuuuwuwrwwrggggurwrugugbubrguwbrrwbwurbbrgwbwgu
+rrrugwggwgwwuugrgrggbbuwgwwrguubbbwuugbgrugwbbwwugrwgu
+urubuwwurwgurgwbggurrgrugrbwgrubbwwurbwubwgbgrgrb
+bbbwgwrbbwruubwwwwwbuubrrrguwguubbbugwrwwgugrbwugbubguwgu
+rurbwuwgugrrwbrgwrwwubgggbwugbbgbruwwbbwrggwbbgwgwgu
+ggbgbgwruwguwbwwgruwbbrbgburrwgubuwgbwrbwwwrggwgurwbw
+guwrwuwrrbwrbgugwguburrwbggurwbbrugwbgrbrwwwbwrrbbbubbw
+gwrgwrggwrgbbwuwbbwuwrgrggwgrbrwrbwbwuugrbubwwwbw
+bbwguwgwrggubrgbuuurwwwguubgbbuwbrgggguwbubrbwwrrrbwgu
+wrbwgbgwbbbwrubwbrgrwbrguguwrggbbwguwubgwbbbguu
+buwuuwurgbbuwgruwwrbbbrbrgggwwuwrubgrrbbbwwrrbwrwrbbwgu
+urbrbgugbrbgwbgwrwuuwguwgbgubrgguugbwwgbbbwrrrbubgwgu
+wgwbguwugbwguwburgbwuruuwwuwbgrbbruggbrwwruwwrugu
+ubburrrbwuwgubrwgrrbbwwrgugwgrwbugwuwrwwuwguru
+wwrbgugggrwwrbgbbbbuuurubrugrrurgbrrwrurwbwwggu
+grbuggwbruggrrrbrwbwgwubgwuubwgrwwugbwggrububgrbgrg
+brubwgubwrbrgruwwrbgruwrrguwuurwwrubrububrbgwrwrbgbbwrgwu
+wwrburrburbwbbbrrrggrbuwgubbbgwwbgbgwrububgg
+uurbgrwburugubguuwgbwruuwwubbugbgwbbggggrggrb
+uuuuurguwwurrbrrgrurwuwgbrwbggbrrugwguurgg
+rrgubrwbwwuwbbgrgbuuuwuuubgrubbgwrrgrbbrgwb
+uugwugrrgrbgrwubbrbuwugbrbgbubuubggbbgwguwwgu
+uruwwgurbrwrgwrggrgubburubrrurrwugrwbrrgbugbbwbgggwubbu
+rbbgguugrwgurwgguggggwwwwurbrgwbbbgwwruwrbuugwwgrrugurbb
+gruurgrrgrgubrugrubwugguugwbguugbrgbuuwrurruruggguwgwgu
+bguugrgrurgwggbbbrguwugbrrrggrwbguwwwrwwurrwuuwgwggbwubwgu
+gubgbwgbbruwrwwbbgubrwwrwwwgurrbububbwbwgbwuwbgbuwwgbgwgu
+wwwruwgubrbbgbburrwgwbgbrwgbrguwrbbbruuuwgrrg
+wuwbwurruwgbgurbgrwggwwwwrggbuuugbugrbwguggwggrr
+rrrwwwuwurggbbwuggruugwubgwwgbbgrrgwburwruurwugwuu
+uwwwuuugrbwbbwugrwrruuwrgurbbgbubuubgugbrurwr
+bbuurbggwuwbwbuurrrgrwbgrggggbwuwgwrwgrwgwg
+gbwrwwbwruguugwwbgbwbugwggbubgwugwbuwrrgbg
+wurbwgubrwubrrrgurgrwuguwgrgwuwwwgwguruwwurgwgu
+uuwgwuuruwuugrrrgugrubbuwgwugrbrgbgrgwwbubrubw
+wwbbgguwuwurugguugwggwrurguggburgbguruwbrbbgrbgwuwbw
+uwrgrbuwbrbgugrrbwuubrrbgbgrbbbguurugggurgrur
+wbbubggwuurugggbubwrrgbgrubggbggugwwgbggwwubugwbgrrwgb
+rgguwubwwrbwgbgggbwruwuwugrgrggbwrrwbbbugwbwg
+ubwrbbbbbbrbggbbgrwwuurwwggurrrbrbuwwuwbwrgruubuwuur
+bwuggrwwgwubbbwrggugwwrbwrrbubbugwggurgurwg
+bruugbgwbbwwbrguwrubggwwrggwgrrrrrrrruwgu
+gugbrugurbuwgrrugugbuugugrbbgwgguuuwggburgwubguuugrwggggr
+rbbrrbrbbwwgruwrwuwgggrbbbgbuwurgwgwggurrgbggubrrrugwubwru
+guurwbbubrbbrwgrggrbruubwgbuwgrugrggbbbbuubrwugburww
+bgrubggwwgwgggwuuggwgurbgggbuwurwbwbrgrguwuruwuwu
+bubwubbburbbggrwgbwurrwgbwuwrbugbwuuruwwgwubrbuburu
+brbbgrrbbuuggwbrrrwggwwugugwwbwuwgrbuwrurbuuggugbrgr
+bbuubwuubbgwwbbbgbbwbbbrgbuwwbbbburguwrgwgrbrbbbgrwrbbbr
+ggwrbwgggrrwbruubururgwruubbgurwbuwbwrwrbrrugguubrrw
+gwuguurrrwwgwwgwgwgrurgwuugrrugrbwubwrwrwwbubwwgugbbwgwgr
+rbgbbggrugwwuguuwggbugbrbgwgbbwggugruubbgugwgbb
+rrgubuubrbgrrubgguuwbrguwwubbubbububgbbgwgu
+gbgrgrwbwrugbgbgwwwwubwuwbwbwuwbwrwbgwbugwgu
+wrruguguguugwwwgwwgrrubbbgrgwgugbrbrwrrgbrubb
+brgbuwgbubgrurrgwrbubbbggbwruurwbrbbuwgrwuurbgrwrbugurbwbr
+uggrbrwwwbbrwububrrggrwrwubwuwwubgbuwgbrbbrg
+urgbggrwwwuruugrurgugrrbbbwwgrbuwuruugbbwrrurrwwwuguw
+brrgbuwwrurguggrrurbrgrgbbrbburgwwbuwuuuggguwbrwbbgb
+uwggwgrgrbbgwruwbrwubrbbrrurgrbrgwbwbuwgwgwrgubuuwrbgu
+brurrrruwrgurbgbwuwwwwrrrgwwuuggrwwgbbwgrbggubr
+ugrwbbwgbbbruggbgrwrgrguubbruuuwwwrrbguguwugurwgbggb
+ugwrubwrubuuubbbrurruwurgwgbuwbrgugwurrgwwburbubru
+wwgruuubggbgwbrbwgbuwwgbrubgggrrrwrugrggwrbrrwwuw
+bwrrrbwbbwrgwguuwubwruwgbbuugrugbggubwuubwwggrrwbrwrbwrgg
+rbbgrrwrgbrbuwwurbgwrggrbguuburubwbwbuuwguwrbrw
+ugrbubbugbrbwgbrgbuuuubrubbbrurwgurgbwuggbrurbrggugurruuwb
+wubuwurubwrrbrgrguwubuwruugugbubuwrrugbwrgwgwug
+uugurwrgwburwgbuuuwwwwrbgbgrubrrubbuguuuwbbuw
+gubuwruubgubwbrbrwwuuurwrurbrruuurrggwurwgw
+wggrbugwuuubbgrbgwuwbrwwbuuuubwurrwgubwuur
+wubugrubbrwurbuwbbgwubrgrwbubwwggwrbwggrgwbgrug
+rwwgwbwwbugrbgwbbbbwgwgbbuurrggwbrrgwgbbuwbrguwgu
+ruwwubrrrrbwrgruwrrgwrgwbwrguruwrgwubbbuggwrugwgur
+gwgubguwguwgurrruwbwgbubrwwrbggwguwbbrwwurubburwg
+ugruburuurgggwgbwugbuwgugrgbgrgbwuugruwbwwggugbwrguguuwgu
+ggubwuwwrbrubgrrrurrurwbugggrguggbwbgbwwuwwwgwggbggbwuuuw
+rgbggruubugbrurguurggurgwwrgrbubrrrubrwgbrggurguub
+rgguwwububrwgwgbguwgurbggrrwwrrbgwrgrubwugu
+burwurwrrgggwrwguburubgrrwrurgrbrrrwguguuwwburgwuuuruwgu
+wwuwurwrgggrurbbwgrrrrbwgrurrbggguuwuruuugruruuwburwgrwgur
+gwrrwruurbwgbuggbgbbgubggwwbuubgruugrwuurgbwuwwu
+bgggwrbrrrubbbbwrrrbburwgurbburwugubbggwuburbwbuwwgwwbuggwgu
+rgwuwgbbrugrwguguubwguuruubbgwugbguwurgrgbgruuwrwbg
+ggbrguguruuugwrgwrwbrbwwwgrwwrubbrwuuurbrwrrb
+bgruwubbbwrgwwbuuwrrwwuwubgrbwwurwbbugurgbgrbgggurrrw
+uurbugwuwuwwrrrwbbgwgwubwwbrguwuwrgggwuuruwrrgwbwrbbgrbb
+gwurwbbwurbbwurubbwwgwwwrrrbuwrgubbwbgrbwwbugrggwu
+wrwugwwugurwrwrurwurrgrugrubggwubwgbbguurbugrwubgwgww
+gbggrguuwuwgrwgbrgugbwwbbwuwrbwugrguuwururbbgrbwwggu
+ggruwrburubgubwurbbwbbwbwrbguubbuwwgwbbwrbbuwgrubrwg
+rbwrubrbgwwrgguwwgwrbwuurubbrguwbwrrrubbrrubbruwubwggw
+ubbrrubrbwrubbrwwgrbggbgurrwggwbggbrbrrbgurbrbur
+bwwurruwugubwrgwrwuwbwbwugurggwbwurruggggbbbrwbggbg
+wurgrugwugbuggbbrgrburgguwurgurrubguwrrgbuwwg
+buwuwrrurruuruugggggbwurubbggrgwrgrwgwgwgu
+bggrbbbgbubuuguwwgubgrgrburrrbwrbwrruwwbuwbwwbwgwgu
+gwurbugurwbbbrbburwggruwgrwburruruwuugggggwuuwbur
+rrbwgbbwrgwbwuwgwwuwbrubbwrrrubbgruggbggwgu
+wrrbruuwubugggbubbubwbgbwwbrwbbgguwrwwwwgugggggwurggggu
+gwgggbrrugrugbuugbbrugrbgugrwrbwbwrwbgwrubwubrwbbwguuruguw
+wwgbgwruubrbugrwrbuuurbrgwrrbgugugbbrwbubbrrubgrbugw
+rbbgwrgbgwgubwrguuugwgrbwurbwbbgwbrggurwugbgbbbuw
+brgbgburgbrugbwrwgrrbgugbrwugbgbgwbrgwwwwgg
+rgwbugburuwwrrgbgrbgbwrubrwwbgbubrubwurguwu
+rugurrgrgrrwgwrbbubrbrwwwuwwwwuurwwwwubbbguwuwggwgu
+ruggbwbgbbuwbugrubgugubgruggwrwwbbwgrwugwurwuuru
+wbrrwgbwbrbbbgwrgubuuuwwgrgwrbwbggwwwugbwuwwr
+rwbgwgwgrrbbbwgwurrrrbrugrbrgubrrwgwwwuwgwrwrbrwuwu
+wuwrbgwrbbuguuurubwrrurwwgrugbrurgbrgrubrurrwwur
+gugrurgugrwgwgwrwrrggrwgbwwuwurbrbbgbuwuubuggrwuuu
+brwwwguwbgrubgrgugruwwrbrugggbggbggbgwrrrguug
+buwuwugggwwwrgwrugubugbrugwrwuubgbbbwwbgrubb
+wbrguugwrbwgwgggrggbrgurbggrugubbwrbubbwggwrbuubgrrgrwr
+wrgrbwgwrbwrwgbrubwgwubbrgrguwrgrbuurgggggg
+wbuuggwurbwgwguugbuuuwugrwbwwuuuggwbuuwwbbruubwwu
+buwrgbruwbwwrgbbbuwrrrrrugbbrubbgwguuurbrrgrwuubgwguwbb
+urbuguubguwuwrwwurwwuuwwbwguugbgbgbububwwbwrwgwugwgu
+ggrgbrwrbwuurggbgbgrbugggwuubbwrgwrgbgwrrwgwgwuug
+uwwubwurrwgggwbgrbbruuwruuwbgbrgbgrbrubgbwgwwubwgu
+rrugububgrbwuguguwrrwwwrgwbwurggruwgbubbruwubuwgbgww
+uwgwgwbuwgrbgrgugwwwrwwwbuuwguwwgwuggrwbrrruwwbuuw
+bbrgwubwwuwbruuurguuwbgurwurgbgubgbrrbbwwur
+bubwrgbuwbuwugbbuburbuwggrrbuwuwrbugbbgrurbwgu
+ruubggwrgbubwbwugwrbubrrbrbrwgbwgbbuguwbrgurwgggbbbr
+brrggwurbgrrrruugbubruwrrwggugwgwwrbggrwrbguggbbbru
+buurwrwwuububbuwwuwwwbgwgubuugbrguugububbgggugbwgu
+brwuguwwggwbuggurwbuwubwgurwruuwbrurgurwuwurggbbwurruugwbg
+wrbrggrugurwgugwrggrguwrwugubwurwbrgrrbrbwgbrbuwuggbwbru
+bbbgrbwwwurubrgwwwbwbrrbbrgrruggbwubgwuwurbugrburwgguurwgwgu
+ggrrggwbrgguugbwbwugwrwuuruwubrbrbgwbbgrru
+bwggwrbgrgrrwrgwrubggwwrgwwurbwrururubwuwbruwurwgwwuwu
+urbrrugruuwbrwwrwurrwrrgbwgubuwwbwgggurrgugbwbrgbugwbggbwu
+gwugbwrugrgbbwrrbwbwgbguwggrrurbbbbugrggbgb
+brrgwrbwwbuurwuruwbwwwwrwbbbwggwgggugbguwuburr
+ruuuwgbguurwgwugwggrwwrbbbwugrbururbwburwwruuwwrugrur
+wrbuuwrwggwwrrbgwwrbuuggbgrugwrgugguruguwb
+rbrrwwbuubgrrbuwurwwuwgwguubgrgrbubrwgugwrbgruburbrrug
+gbwgugrbwbwgrwwbgbrrugwgruubwggbgruuwrwgbwrwrgbuw
+rwgrbbbgwgubrbwuubrrubbrguubbuwbgrbguggwugurgbguwrrgbb
+rwgbguwuuwgbrbrrgwgrrwuuuguuggbggggbwburugwurg
+wgrggbbrbrrruwgguwggrgugbrrbrbwbugbwwrubbbbuwu
+wrurbrubuuugugwggbugrubruwbburrrrwuuwgwuwggbbuguw
+gbrrwbwruwrrbrruguuwgbwwbugrwwugwbrgubgrur
+grrrgguwrrwwrwwgbbrgggwgbguwuuubbwugrrrugrggrb
+uurgrwubwbrrgurrguuwrbgwrbrurwrugrgubwwgwbwgbrugbgwbuguwgu
+bwbwwgbbgrwwbrbbbrgbrbwwwuruuubgrgguurbuuwgu
+grggrwbwgggbrgugrwguwrubwbuwgurrruuwbgbrrgb
+bbrruubuurbguubwuugrurbwrbgbwubwubwwrwguwug
+uugbrugbgrbugguugwbwbgrgbuurwwbuubgrgrgbrw
+wbgrbuuurbbruwwwgwrrbguugbuguggwwwuurruuurbbgwwrbgwg
+ggrrbggbbgbgwrbgggrbbbrububuwrrbuwbbwrbgrgbgrwbb
+bgwuguuubrwwuwgbbgbbbuurwwwrwwbrgbggrbbwguguwgu
+rrbgwruwbbuubbuubrbggbugwwwgbgrwgugbubwbgbbbgbbrgug
+rbwbrgbbggbburrrwguwwuwrugrgggggrwruuggrbrgubgwrwbrrubggwgu
+guburwgburrgurggurgbgrwwwbuubbwwruwrubbrbbwrgwwrruubbwbu
+uwbugwbuwrwurbrwrrrwrwwbrgrbbbwuwrrwrrrbbbwwrwrrbwgbrrgwg
+bruwrgwrugwggrgrwgrrrwwgwwugbwurggwbrrwbgwgrgurru
+gwuuruurwwguwugwurrgbuwuwwgrwgurgbbrgwurrwwg
+wgrbrgurburugugbguwwgwbwwgggbuuugwgwrwbrrrbruburwrwwgwbbrb
+uwggwbggwgggrgrbrubrbruubguuwgurggwbbrbbgrrbug
+rurbgwgbwuwuwuuubwuguwrbwgbbrururruwbgwwbuwbrrwrrurwgg
+ugwuuuurubbgbwrwgbuwrbbrwbwgwuugbrguggbubbggggubgrwuwrbbgg
+wbbugbrbgbrruwguuruwwgwgwrguwubguuwurbgwbbguwrrrwwwburguuu
+wuugrbbrrgurgbuuuruwbggrggbubwubbrgbuugrugwbgwguwrw
+guuwwrbuuurwrrwrwrwrbuugwwbuuuuugugrgbguubrrbggbgu
+rbwbbruuwwbwgwbwgugggbwwrwugguubrugubwgbbrgrbgu
+bgrgbuugggbugwbbgwurgwguuuruubrubwbubwgwgwgurrgbubrguubr
+rbggruugwbuwgugbuubugggwbrwuurgrrbwwbrurbgwbgguugbburgwgwg
+guwuurbbwwbbuwwuwwggurguwuubuwwwgrugwrubgruurwgbwggb
+gbrgbwwuggwuwgbgwbbgguwrwbwbwrwrwururbuwbgwgrrwrbuubwrrrbu
+ggbbwgbbbrbwruggurwguubbwbguwguwgbrwrrruwubrurbuguwgurgu
+bbwbwrugbwuwbwwbuugrgugugugrgwwuugwrurruwbgwwbwbwr
+gbwwwuwrwwguwburwuggwbruuwbbrubgrbrwrgwrgrgugwgu
+rrbwwbrrwgwruwwwrrgwubbugruwguggwwubrrbwwwwggg
+urrrgwgggrrrurubwurgurwgugwgrugwbbwbwwgbbrwgurgwgwbubgwgu
+rwgbwbrwwbgrbwggwbuuguuuwgbbubrgrggrwguwbrwrbrwrrwwurg
+grbrwgbrwgwbwubgrbbgwrgrwuugwbuwuuwbwugrrwg
+rgrurbbbggrrguburrwwugbgbbgbbbwuwbwrgwgwwbruuruww
+wubbgwgbggwwggwrwubbrbwrwrbruburbgwwwurgguwgr
+bbrbgbwrrbgwwwurggwgguwruwbuwbugbubbbbrwbggubuwuwgu
+uwubbwwbrurwrrrwwurbgwwrubgugrbbgwbbbrwrrrgrbruubbbburrgg
+rugwrbwugrgwwgwbbwguwbuwbugwwbugwwwurwbbguwgbgrwuwrggbgrr
+rgwgwwwuwbgwbuuwubbuwbruwgugbbugbbwrbwggwbgbwurubbrrgbrw
+urwwgrbbgbuwuubrubruburgugbgbwuurgguuwuwubwbuggbwbggwugwgw
+guugrwbbwwbwbwbuguurubuwwwrrbggbrruwwwurwbbbrbbb
+ggugbrwbgwrbrbbbrgguggwgrrggwgwrgruurgwurggwwgubgwgu
+wruugbgugwwrgbwbrbbbgrubrwbgwwguwbbgubwrguwuuwubgur
+bwuwubbugwgbrrwuuwrgbgbguwuurrbbwrwugwwwrbubgrrrwbw
+buwrbrgwbgwurrrwguuurbrrbuuurwrgwubbgwbgggguruwbgbggb
+uwbggrgwbubrbrwwwguguwrrugbbbugbbgwrrwwwgrwgbugurwrurr
+ggurbuwrwgurrgurgbuwrguwbwbrugbgburwuwuuwuubgggwruubgubwgu
+gwrrbbbgwbwuwgubbugguwurrwwbrugugwwrwbrgurrrwww
+gwruwggwrubugwgubrruruurwrggbwgrubbuubgrruwgrburwbgrrbuwgu
+gguugbgwrrbwwrrgrbrwuggrbwbgbgrwrbuwbbubwgubwuwubbg
+rruburrrwguwrrgwwuuwwbrgwgrurwurwubrubuurbgbbggrgb
+wbrgwrbgbrbwgwbuwurgrrruwbwrugwbbbgwbgwbruuuguwuwwbuguwrub
+wwrgrgbuwbbbwwurgugrruuwwwbrrwuwugwwurwgrwurubguwwg
+ruburgggurruugrubggwgugbuurgwbbrrggbwggwwrbbgrwb
+wwggruwuwwguuwwrrgubgwgbwwbrrrwwuuggugwbuurub
+gwrburbbgbrwugbwrbggrwwwwbrrgrrrurggwbbggbgbubgrrbuwrwu
+wbuubrwbrgwwubrgrrggrrurwbbwrrgwbrguggwuwwugruw
+ugbbuugguuwgwbubrwrwwrwgbbbwrwgburuwrbbuuwbw
+uuuuwbwggrrbbwwrwgrwwbwrurrbruubwwwgbgrgrrwggwwuugbgrrb
+gbbubwubwbgwubwwgruwbgrburbuwwbgwwgbwrwbwbrgwrrubwwbrug
+rwbwwruwwwgurgurrgbgubuuguwbwrugbggrwurbbrbbrbuwwrrwww
+wgwrubgwuubgwgwguguugggwwruurwwgguggbuugwbuuwrbr
+wwgrwrrgrbbwwwbgbgbubuwrwrbbbrwrgrgguwgwwugggbbgbrbwrgug
+urugwubwgubrwrbuubguggrbuuuuuwwurrgbrgbgbwwubruwuuwwwggugr
+buwuburbrgugrubggbgbrburgwrgwwgbuuuuuwgbwbrbuugrwbbbwb
+uuwgwwbwuurbbggbwrbwrbbruuururwgugwuuurwgrgrwbruwuwru
+ugubbwgubrgwgwwurbuurwwrbrwggubbguwrggrubrrbuwuubbwbrbrb
+grwwrrgwrubbwggwgwwuuuwwrwbbwbbguwubwgbrgbrgrgguugrrgrgw
+wrbrgrgwrwbruruwuwurrbwgwwbrrrwwwwrgrbwgurgrwugwuwgu
+uuguwwrbgguuwgubbwrwugbrwbbbrbugubbrbrgruugbggbwbrubwg
+wwbwbbwugbggwbguwggwbgrgubgrbrrrgbrugrgwuggubbrrr
+brgwbubggbrwbwuggububwbuuwgggrgggwgbwuwguwgwgu
+gwbwuwuuwurwguggbrbbrrwubbrbrwuuwrbbbgrgurggrrwrg
+ggugugbrgrrrwuurruuwrgbgbgugbbbrwuwbbgrggbwuggugugugb
+bgwwurubbguruuuwbuuguwwbbuuggwgbbgrbbubgubruwbgbuwwurgu
+uuguwgrrbubwrgruggubggwrgururbrruurwgrgbrgug
+ggwubwbwwbwggguugurbwrrbwrrgwrgrgbubuwuurwgbruubbwgu
+bwgbguwrgwubgrgbwuwgrggbwwrgbgwbruuwgguggu
+wbgbuwrrggwgbubgrbuugrrrwrrwguurubuurbgbrb
+wrbwbrurwrubugrrrbugrwugugrugbwuguubbrgrwwgbrruwbbwg
+gbuguwgwwgwuggrbggwbrruuwubwrgwbrwgwguwrgbwgu
+gggggbbururwbggwgwwrrguurwwgwugrrwuggbubrgrrugubgbugubwgu
+wurbgwbuguwbbgubbgwbburbbrwbbubwrbrubgugbbugwuw
+uugggbugbwwbrwuguwggrgwrbrgwwrugwgruruwgwubbbwwbbguuwugbr
+brugggrwruuuggbgwguuurwubgwuuwbruguwwrgwgbugrrwbbrug
+wurrrrbbbggrwurubbruurbrrbwwgrrrrgruubrrwwwr
+rugugrwbubrgrwbwwbuugwurrwuuguugrwurwrbbbwrbg
+rrurbgrgwrwuguggurbrbgwbgugwrbrugbggrugrrrggrw
+ubwwwwbbguugrurbgrwwgruubggbrrwgbgwrwbrgbugbbbbugwbwbb
+wwgubgrrruurgrguwrgwuwggbwbwruggrbgrbrbwgguruggwgwuurbbuu
+ggguurwuuruguggrrwgrwurbwwbwwbwrbrugbgwrwugbruugbgg
+urgbubgwbrwrgrbwgruguwugwbgrgugrgbwubrgrbwrr
+uwbwbbbbrwggwrrggwbgbwrgugbrggbwuwgubrwbgbuuwugg
+wwgbbgwrwrwrbgubgggbrbguguguubbrbbrurgbbgubbbbwgu
+burwbbguggbwwubrbugbrwwbrgwgruwrrbuggugwgu
+brrbrguwuwbrrrbuuubwwrbgbubugwwurwugrgrwurbugwwrbugbw
+gburrrgwuwrbwugugrrrurwrrrbuugruurbbguggugubwgb
+ruugrbbwbubuggbbuwgbbwgwurbrgrbgruwbrburggubrrwuburuugbur
+wwbwrbwuwguguuuurwubrwbrburbggrugurwbrrrwwbgurwuwg
+urggurrrgbbrgrwrwrbuuurbgwrugggrwbrwbgggrugg
+gurrbgbbrugbwrgwwggrururbbgwgwwbwubgwrrbubwbuubggbrbrr
+bbwwbgbrbwwrgwwrbgwbgugurugbugwubguwubruurru
+wuurbgrrgrwurrguuwuurwbwubrbgwbbbbugrwwwwbbbwwgwgwru
+uwgubbbwuwugwbrgwwguubwwugugwbubguugwgbuurgbrwbruuubuurruw
+bbruwrwuubwbugbbrbgggbwbwbuwuuubrgugugwbwwrbuwgwuwgu
+wgrgrbbgruwrgrwgbrwrwguggguwwwubgbwuwrgrbguwu
+bwbrbbwggwrruuguwgwwgubrbgurrgburuuguuguuwggwwbu
+ugrbrwugrwbwgbwbwbwrgbgugwurwwgrurrrugbwbggu
+grwrwbuuwbbrbbbuwrwubbugbbbwwgbwgruwbgrgbwguwwbwuww
+ugrgbwburbwbgrgubbuurwubrgrwubbrrruwubrugrwrwbggb
+wwrwwrwrgurgggbrubuuuuurbbrgwrgggwgrwbuwrggruru
+gwwbbrburbuuuguruubbbggwgrgrubwgruwwrbrgrgruugwrrww
+ugwrwguggubrrwwurwwwbwbwbbwwwwwguubbwwurrgwwgwbwubwb
+wburwbggrbgurbwubwubggubrwurguwbbbggbwrbbguwbwbwuurgbgg
+rwwgggwwwbubgugbubuuwwrbbuwrwwgwggbbbugwbrgbwuuuuw
+brggrwbbwrubburgwwrbburuwuugwrrwuuwgrrrbwwwgguubwwbbbbuwgu
+wuwrbwuwbwrugbrwubbbgugbgwgwbubwuurbggwwrrgrbggbw
+uwrrgrrwwugrburbbwbwbwbwuurgrgubbwwuwrgrwgbugg
+gbuwgwrwbgbgrruwrgugwuwbgwruwrbgbrrwububbrbrrbgugr
+bgbbbwwwwbbubwrgwbwrrbgggrwggwgwgbgrbbgggugwru
+wwgwwbguuwrbwuuwugwrwbgrwbururbugrrrgwbuuwrwwuuu
+brgruuuugrgwuuguwbbwgrwgbggbgrugrwwbbugrwwrrubwgu
+wburbrwbwrbwrbrrgggurruuguggwuwbrgwbgbwgbrwubgubugbur
+rgurgwgrubuuwwrugugbbggurbbgwwrrubgurwbwbbbrurburwrwwub
+wguuuubwubwgwrwuwwuururbggbgwgbubwwrwrwuuwgwbbbrgr
+uugubgbguwbggguuggrbwgwwrrguwuwbubwwrgggwgbwgrb
+gbubrbggrwwgurbbbbbuwbbwggbuwbuwurrgruwwgub
+buwrrwbuwwgwbuwuurguuwbwrbuugwwwuwgrrbubbrgrbubguruwgu
+ubruwgrwbwuurrruwbbwwwgrbbbburgwwbbuuwrgwrguburwbuggguw
+gwuuuuwgbbgbwgggubuugrbbwrrurbbrburrrgwgbwguwubwuww
+rugugrbbwuggrgbbubggubbggbrgwrbrbgubbwgu
+uuubbbggurgubgrbguuwwrgbrgrbbrbrubwguwbubwrgwwbugg
+gbwrrgubbrwgbugbrrruwubwgrwurrwwurwgwrwbrguwrgwwbrwwuwgu
+wwwbwugurwwguugrbwgruurwwrgguwuggwurugrggwguwg
+ugbrwwbwwwuwwrgrwuwbuwbgwurubwuwuuwguwubwbburwrwubuw
+grwgrggggbgwgbgbrwguugwrwbgrrurwbbwburgrwwbbwwgggrwwgugwgu
+gbrbbgbwgburbbbrwbgbuuguuurrrrwwbggbgrubuuwwwwrb
+brbugwubbrgbuubwbuguguwuugbrubgbrwwugbuwbgbwuwwbrgubrbwruu
+rbwrwurbbwubwrgrwrggrwugbbuwburwuggwgwbgbwrgwbgw
+brurwruuubwwruuwuwwwuggugrbruwbgwbugrrwurugrgubrggbwwr
+gugrwgubbwbuugwgrgrrrgwbbrguwubruwugbugrbbruuurwgbgur
+ggbrgubuwwururggrburuuguguurgubbrugurbwrggrrwbwgu
+rwuugubrrurrbguuugguwwwugrrgwgbrguubgrwbrrwguwbw
+uwuwrrruwrwwgrwgrbbwwwggwgubgrrrwggubuuuuuubrbbwgu
+ruurrrgrugrgrgwwugrwwgrbuuguurgrbrbgrwbwgwu
+buubbwwbwwrwbwwbgurgwbbrrgbwbwbuwwbwbggguburrbrrbwgurgu
+bgrurgbrrurwwbbrrwbrrrwrgrwbbrugrwbwrrgubbubrrbrgbuuwrgww
+rwbbwbgwbggwwgugrguwgbuwwubwuwwwwuwbugrwgrgguu
+bggbubgugwbbrurrubwgwbwwwuubbrguuurwruruwrwwubuurr
+buwuwbrrubbwuurwbrgwwwwrrgruwggruruggbrgwbwwwbwugrwgr
+ubbuguurburrrwggwgbwuwwrgwurgruwwwwbwwgruwbugbuugrrggbu
+ubuwrbwgwrbgugrwubbgrbwrggwrgrubbbbgurwrrwuubwbrgbbbbuggww
+uruwwuubrbgubrurwbguwrugbwruggbbwwuwuggbrwuwbuggbrbrgrbr
+uubuuruwrbbwguugwgubbwgwubbruggrgwrrgruuwuwbgwrrrgr
+gwbububbgwbwgggwrwurugrrruwuwurgbrwbgbwuwuggwgbwuwbur
+ruguuwwuurgwggbbwgggugugbbuuggwbwbbwgrruuubwrguwrruugwrbb
+bwwrugwwrgwruubbwwgbwwrwuwubbwurrrubrwwwubbubugugbuwb
+rrbwwggurwuuubgurbbwgbrbruuwbuuwwrbugggugw
+rwggguuuwbwuwwubwuuurrubgrguwuwbrgbuwbgugbbbbrwuruuurgrw
+uugubuwwwrwwuwguubgrrbrrrwrrgwubbwwbwrbgguguuguuwru
+rwugwruubgurrwrbgubuwrwuwugrwggrwwwugbubugwbbwgwburbbubwu
+bubbbrgrgbwgubwwruurgrbrbbwgbgrwgggwrbburubwb
+brwgbbwrbruggwrrbuuuuuuuuwrgbwuggrrrugwuwgr
+wggbubwgwruwrbgrguugwbruuggwbrrwbgwuwrgwwurgugwurbwbb
+gwwbrgrrrwrbgwubrwgwrwbgbburgrrwbuwgwgrgwgubbgr
+rurgrubwgwrrubburwurgrbrgurbrguwugwurrbbbbwwbbuw
+wgwugubruuugbrgrgwgbrurwbgbwbrbuwgrwurrgruwgu
+gguwggbrwwugugrbwrbrwgwwgruggurgurwrrrrwbwgu
+wwgbrrgwwuwubbuuuggbgwgrwbbrgubwwuwurwrbubggrgguurgw
+wrrrgwrubggugwgwburgbbwguguwwgurrwwgggrguguggrugwwwgu
+ruwwbrburrrrwgurruwbwgruggrbwuwuurrgbuuwbgbg
+rbugurbwgurwwrbwrruwgbgwwrwgwggrrguugrbrgwwgwwurubbrubrg
+bbbbguuuwwurwbwbggbrgwwugwbugrugubwuuwggwbwuwwrgbrguuwr
+buwubggbrwruburgbubwgbwwrwrgbwgwrwuuurrgrrwwbrrrgubb
+ggurrgbrbggggrbgwbuwurwbrguugrbuurwrgubwwubbbbwrwuwbur
+ubbwubgbrwwgrgbgrwbrruuurbwrwrgwbgrrgrbgrgwuuwwururrbr
+rrugruuwgbwuwgwuwruuwwuuguurrwbwrgugbgwwubbg
+gubuubrbbrrurrbrrwguguwrwgbbubrbuwwbuwwgubguburuggrgwr
+wguwrwrwruwbbbbwuubwbguuwurwbubgwwwwrbuugww
+bbggggggbuwgurgwurbubwubgbgburbwrrbrrrwbwubwwruwuwbggrrugg
+ggwrgbwruubwwuurgbbwrgbbgwrubwgbrbbbggbrurgugbbwgbgrugu
+ubuwugruwbrwwbbwbbuwwubgrbgbgggurrrrgbbgwbbwuu
+rrgwwggwgurgurbbbwubuugbbbgwwrrwrburubgwgu
+ugrgugbrgrwuugbuwgugrwrbwbugbwggwbwubgbruuuwbrrwrbwuu
+urgwwubwuubruguwwgurgbwgubgggbbwruwrurwwgbuwrrrbwwuw
+bgrgubruwrurggrbwuwbbwwugwburbubrrwurwubwrruuurgubrrgub
+rgbrrrwwbbuwrbruuurggurubggwbbrrbwbbrbgwrbuwgbgg
+rgguwggugruwwwbrbgrrbwugururguwuuubgruubbwwwu
+bwwbrrwuurgrruwgrguwwbgrrwrbwuuurgggbrwgbuwbguuuwggwbrrgwgu
+rbwwwrbubwggrugguugwwgwbuurburbrubuwgbururwgrgwwb
+wwwgubbwbwbgwubrrgbubuwbbbgrrgrwwrbbuwbubrrguuugruwwruwwb
+ubrbggrwgrwugwwgrugubrburgggbugwbggbburgugggwbugugguguguw
+rrrgrgrwgbgwgrgwrurwuwgurrbwwwgbgrgwwbwbubrrubrru
+wbwgrgbwbgwgbuugburrwburbuwrbwgburrgwuwrggwbwuwgbbbguwrbgr
+rwgburgwgubuugurwbwbwbuburrrbburgwwwwguwgwwbwbbwwwuwbwgwug
+rwbuuguuwrrgrwrrgruruuguwwwgbbruwbbwrbrguwgu
+guwbggbgrbbbbuwrwguwguwgrwurrwrbuurrrgruwwurrw
+wbwuuuggwbgrwggbrggwbwburgbbrwrrugbbrugurbgwgu
+wrrubbwrrwbruruwggugwwgrrwugugrgrguuggrubrggugggbrwu
+rugrgguuuubbuugbbrrwuuwgrbrgbgrbbrbugururrg
+ugggrgrwgbgwbwwrrgggbwwgbgbwrwwgwubbbrbbbuuwgwbbubbbwubw
+gwgwuwuuwgbuubbwwwrrurrbgbubuuguwwbrgwubuuwbgwwuwbg
+rurggguuubuuwrbrgwgguurwgrwugruugwwggrbuuugwbwgu
+gbburubbgbggrwubgrgrurbwgrrubuwrrbbgrgrwgg
+wgrrgwurbguwgbuwrbrurruwrbgrrbrgggguugrbwgwrbwwbrgwgu
+rgbwbrwguubrwwrwugbbbwugwurwwgurbbrgwwugbbbwgb
+ruwwgugrgrgrwgrwrbrrggwurrrwubrrbbrbwubrbwgu
+brbwrrrggrgrggbwbgubgrrugwgwuubrbwwurbwbru
+wrbrwgbwbbguburgrrgwrbrwwurugruggwgrrrurggur
+gggwrgwwbuwwbrbgbrbbgbbubbuggrgrggbwugugggrbub
+urgbwrgbgwwrgbwurgggrwgbbgwbwgrwwuuuguggbrbggw
+wwubrgbwrguwrbrurrwwwgrwrbrbrrbrrwwgbbuwwwbbbwbg
+rrgugrbrbuwwwuuwwurgubgwbbruuggbbbruuwubur
+urguwgrrrgbrrwbggbgurrrrrwggrggrrburrrgggbu
+ruwgguwurbbrgbgwgrrubwbwurwrbwgburrbbgrgburgubwwgb
+wggwubbrwwwububuugwbwbubrubuguwguwrbbrwbgwgurgu
+uubggrubwgrgbrurgbuwubgbuuwugwbuururrururgggrurwwrrgrrgbgwgu
+brrwrbrbggggrwrburbrurbuwuuguwbbrgrruwbugwwburuuugubwgu
+gbwrruugrgwbgrbruwwgrurbgwwubgwwbbggubgrwubrrburrgwuw
+uburgbbwrgrwurwbuwrrwbbbggrruwrugubruwbgwubggurbuwwbbuwgu
+wwrwguuwubrbbruguuruugbwwwrbbuubbuuubbbgrgr
+uuwgbbgguuggrwwrrrubbbbgurgrruuubwwugwgu
+guggrgrbrburubbugbugrgrggggugwgwggrrwwgbbwgu
+rbgbbwrbwggugurgubbwwwrggwgwuwgrbrrbgubbbbruw
+uuuwgrrrubbrwrbggwgguubbwbrbrwbgrgwbubwggwubgrub
+rurwruuwwgwrguwugruburbgbuugugwuubrbbwurgrbrbugwubr
+urrruurwuwbbbwububwrgguwbrgrbuubgrwuguwurwrbubrugu
+gugwgrrrbrrrgrrwwgrggbuggbwbwgbburbwwggguwrub
+wguwwwgwggwwurrrguwuwbgrgbrgwugbwbwwggbugbggr
+gwgrwrgwbbburggrbwwurrrgbguurrrgrbrugwgbwurwguwbgbgrbug
+rbbrrrbuuurgugwgrrbuwrbrrurwuwgrrrgbugbwgu
+urwgwbuuwrgwwrrggwwubbrbwguuwbwrggbbwwwwbwrrrwwgbwwurbrrg
+wwbguurugruuwuubugbgrwgwwggrbubrggwrwruubwrgwub
+ubgruruguugrwbwbuwbbwruubwgrrurwwruwugwbruuurrwwrrgruugw
+grbubwruwubgugggrrgrbwgurbgwugwwggrrbrgrbuwbbbrbwgu
+wrgrrubgggrurgwguurubwgggbwuwrrubrugbrgbrbggwgg
+gwgbrgrrbbrgubgrubrwrwrugrgubrgruuguwrwubwwwrgbubwwggbbwgu
+bwbwgbgwbwwbuuwbrubggggbugwgbgbuuwggrwuwrbr
+wugrwurwgrbugrwrwrwrrgwwuugrrwgrgbgbuwgu
+urbbubruuggrugwwrbrrguugguuwuuwuuubrbgbbggrgbug
+rrugubrbbgbwrbggguugrbrrrbruugruuggrbgwbuuwuururugwruug
+burwbgbgruwrurbrwuwrgurgrrbrbbguwwbbrwgbwbgwrwbruuwbgwgww
+wbubuuwbrwuwwruggbbugbrrrgbgwguwwgrgurgwrugrguurrrrbbgrbbwgu
+rbwrbubggwuubugbrubuurruguwrrwgubwrwwububwrgrguw
+gbrgubrugbwrgwwwwrbugwwgwgwrbrgwuuggrubwrbrugwbbruubwgu
+wbgrubbrgwgrbrbuuuubuugwubbugwbuggwrburgwugw
+grwgrbgwwrubruuubburwgbwgugwugwwrbwbwwrguwbbubuuwguwr

Inputs/Day20.txt

@@ -0,0 +1,141 @@
+#############################################################################################################################################
+#.......#...#.......#...#.....#...###...............###.......#...#...#...#.....#.......###.....#...................###.....................#
+#.#####.#.#.#.#####.#.#.#.###.#.#.###.#############.###.#####.#.#.#.#.#.#.#.###.#.#####.###.###.#.#################.###.###################.#
+#.#...#.#.#.#.....#.#.#.#...#.#.#.#...#...#...#...#...#.....#.#.#.#.#.#.#...#...#.#.....#...#...#.........#.........#...#.................#.#
+#.#.#.#.#.#.#####.#.#.#.###.#.#.#.#.###.#.#.#.#.#.###.#####.#.#.#.#.#.#.#####.###.#.#####.###.###########.#.#########.###.###############.#.#
+#...#.#.#.#.#...#.#.#.#.....#.#.#.#...#.#...#...#...#...#...#.#.#.#.#.#.....#...#.#...###...#...#.....###.#...#...#...#...###...........#...#
+#####.#.#.#.#.#.#.#.#.#######.#.#.###.#.###########.###.#.###.#.#.#.#.#####.###.#.###.#####.###.#.###.###.###.#.#.#.###.#####.#########.#####
+#.....#...#...#...#...#.......#.#.###.#.###...#...#.#...#...#.#.#.#.#.#.....#...#.#...#.....#...#.#...#...#...#.#.#.#...#.....#.....#...#...#
+#.#####################.#######.#.###.#.###.#.#.#.#.#.#####.#.#.#.#.#.#.#####.###.#.###.#####.###.#.###.###.###.#.#.#.###.#####.###.#.###.#.#
+#.....#.......#.....#...#...#...#...#...#...#...#...#.......#.#.#.#.#.#.#.....###.#...#.....#.###.#.#...#...#...#...#...#...#...###...###.#.#
+#####.#.#####.#.###.#.###.#.#.#####.#####.###################.#.#.#.#.#.#.#######.###.#####.#.###.#.#.###.###.#########.###.#.###########.#.#
+#.....#.#...#...#...#...#.#.#.#.....#...#...............#...#...#.#.#...#...#...#.#...#...#.#.#...#.#.#...###.......#...#...#...#...#...#.#.#
+#.#####.#.#.#####.#####.#.#.#.#.#####.#.###############.#.#.#####.#.#######.#.#.#.#.###.#.#.#.#.###.#.#.###########.#.###.#####.#.#.#.#.#.#.#
+#.#...#.#.#...#...#...#...#.#.#.#...#.#...#...#.....###...#...#...#.#.......#.#.#.#.#...#.#.#.#...#.#.#.###...#...#.#...#...#...#.#.#.#.#.#.#
+#.#.#.#.#.###.#.###.#.#####.#.#.#.#.#.###.#.#.#.###.#########.#.###.#.#######.#.#.#.#.###.#.#.###.#.#.#.###.#.#.#.#.###.###.#.###.#.#.#.#.#.#
+#...#...#...#.#.....#...#...#.#.#.#.#...#.#.#.#...#.#.....#...#.....#.......#.#...#...#...#.#...#.#...#...#.#.#.#.#.#...###.#.#...#...#...#.#
+###########.#.#########.#.###.#.#.#.###.#.#.#.###.#.#.###.#.###############.#.#########.###.###.#.#######.#.#.#.#.#.#.#####.#.#.###########.#
+###...#...#.#.###.......#...#.#...#.###.#.#.#.....#.#.#...#.....#.........#.#.#.......#.#...#...#...#.....#.#.#.#.#.#.#...#.#.#...#.........#
+###.#.#.#.#.#.###.#########.#.#####.###.#.#.#######.#.#.#######.#.#######.#.#.#.#####.#.#.###.#####.#.#####.#.#.#.#.#.#.#.#.#.###.#.#########
+#...#...#...#...#.........#...#.....#...#.#...#.....#.#.#...###.#.#.....#...#...#.....#...#...#...#.#.....#.#.#.#...#...#...#.#...#...#.....#
+#.#############.#########.#####.#####.###.###.#.#####.#.#.#.###.#.#.###.#########.#########.###.#.#.#####.#.#.#.#############.#.#####.#.###.#
+#.............#.#...#...#.....#.#...#...#.....#...#...#.#.#.....#.#.#...###.....#.........#...#.#.#.#.....#.#...#...#...#...#...#.....#...#.#
+#############.#.#.#.#.#.#####.#.#.#.###.#########.#.###.#.#######.#.#.#####.###.#########.###.#.#.#.#.#####.#####.#.#.#.#.#.#####.#######.#.#
+#.............#.#.#.#.#.#.....#...#.###.........#...#...#.....#...#.#.#...#.#...#.......#.#...#.#...#.#...#.#.....#...#...#.#.....#.....#.#.#
+#.#############.#.#.#.#.#.#########.###########.#####.#######.#.###.#.#.#.#.#.###.#####.#.#.###.#####.#.#.#.#.#############.#.#####.###.#.#.#
+#.............#...#.#.#.#.......#...#...#...###.....#...#.....#.#...#.#.#.#.#...#.#...#...#.###.....#...#...#.........#...#...#...#...#...#.#
+#############.#####.#.#.#######.#.###.#.#.#.#######.###.#.#####.#.###.#.#.#.###.#.#.#.#####.#######.#################.#.#.#####.#.###.#####.#
+#.........###.....#.#.#...#.....#.#...#...#.....###...#.#.....#.#...#.#.#...#S..#...#.....#.#...###.....#.............#.#.......#...#...#...#
+#.#######.#######.#.#.###.#.#####.#.###########.#####.#.#####.#.###.#.#.#################.#.#.#.#######.#.#############.###########.###.#.###
+#.#.....#...#.....#.#...#.#.....#.#.......#.....#...#.#...###.#.###.#.#.#######...#.......#.#.#.....#...#.....#...#...#.#...........#...#...#
+#.#.###.###.#.#####.###.#.#####.#.#######.#.#####.#.#.###.###.#.###.#.#.#######.#.#.#######.#.#####.#.#######.#.#.#.#.#.#.###########.#####.#
+#.#.###.#...#.....#.###.#.#.....#.#...#...#.#...#.#.#.#...#...#.#...#...###...#.#.#...#...#.#.#.....#...#.....#.#.#.#.#.#.....#.....#...#...#
+#.#.###.#.#######.#.###.#.#.#####.#.#.#.###.#.#.#.#.#.#.###.###.#.#########.#.#.#.###.#.#.#.#.#.#######.#.#####.#.#.#.#.#####.#.###.###.#.###
+#...#...#...#.....#.#...#.#.....#.#.#.#.#...#.#.#.#.#.#.###...#.#.#########.#.#.#.###...#.#.#.#.#...###.#.......#...#...#...#.#.#...#...#...#
+#####.#####.#.#####.#.###.#####.#.#.#.#.#.###.#.#.#.#.#.#####.#.#.#########.#.#.#.#######.#.#.#.#.#.###.#################.#.#.#.#.###.#####.#
+#...#.....#.#.....#.#...#.#.....#...#...#...#.#.#.#...#.#...#.#...#####.....#.#.#.#.....#.#.#.#...#...#.#.....#.....#.....#...#.#.....#.....#
+#.#.#####.#.#####.#.###.#.#.###############.#.#.#.#####.#.#.#.#########.#####.#.#.#.###.#.#.#.#######.#.#.###.#.###.#.#########.#######.#####
+#.#.#...#.#.#.....#.....#...#...........#...#.#.#...###.#.#.#.......###...###...#.#...#.#.#...#.......#.#...#.#.#...#.......###.#.......#...#
+#.#.#.#.#.#.#.###############.#########.#.###.#.###.###.#.#.#######.#####.#######.###.#.#.#####.#######.###.#.#.#.#########.###.#.#######.#.#
+#.#...#...#...#...#.....#.....#...#.....#.#...#.#...#...#.#.#.......#####.....###...#.#.#.....#.........#...#...#...........#...#.........#.#
+#.#############.#.#.###.#.#####.#.#.#####.#.###.#.###.###.#.#.###############.#####.#.#.#####.###########.###################.#############.#
+#...#.......#...#...###.#.#.....#...#...#.#.###.#.#...#...#.#.......#####.....#...#.#.#.#...#.....#.......#...#...###...#...#.#.....#.......#
+###.#.#####.#.#########.#.#.#########.#.#.#.###.#.#.###.###.#######.#####.#####.#.#.#.#.#.#.#####.#.#######.#.#.#.###.#.#.#.#.#.###.#.#######
+###...#.....#.###.......#.#.....#...#.#.#...#...#.#...#...#.#.....#.#####...#...#...#.#.#.#.#.....#...#...#.#.#.#.#...#...#...#...#.#.......#
+#######.#####.###.#######.#####.#.#.#.#.#####.###.###.###.#.#.###.#.#######.#.#######.#.#.#.#.#######.#.#.#.#.#.#.#.#############.#.#######.#
+###.....#...#.#...#.......#...#.#.#...#.....#.#...###...#.#.#.#...#...###...#.....#...#.#.#...###...#...#.#.#...#.#.#.............#.........#
+###.#####.#.#.#.###.#######.#.#.#.#########.#.#.#######.#.#.#.#.#####.###.#######.#.###.#.#######.#.#####.#.#####.#.#.#######################
+#...#.....#...#.....#...#...#...#.#.........#.#.###.....#.#.#.#...#...###.###.....#.#...#...#.....#.......#.#.....#.#.#.........#...........#
+#.###.###############.#.#.#######.#.#########.#.###.#####.#.#.###.#.#####.###.#####.#.#####.#.#############.#.#####.#.#.#######.#.#########.#
+#.#...###...#.........#.#.....#...#.....#...#.#...#.....#.#.#.###.#...#E#...#.....#.#.....#.#...............#.......#...#.......#.#.........#
+#.#.#####.#.#.#########.#####.#.#######.#.#.#.###.#####.#.#.#.###.###.#.###.#####.#.#####.#.#############################.#######.#.#########
+#...#.....#...#.......#.......#.#.......#.#.#.....#.....#.#.#.#...#...#.#...###...#.#.....#.#.................#...#.....#.........#.........#
+#####.#########.#####.#########.#.#######.#.#######.#####.#.#.#.###.###.#.#####.###.#.#####.#.###############.#.#.#.###.###################.#
+#...#...........#...#...#...#...#.........#.....###.....#.#.#.#...#...#...###...#...#.....#.#.#...#.........#.#.#.#...#...#.....#...........#
+#.#.#############.#.###.#.#.#.#################.#######.#.#.#.###.###.#######.###.#######.#.#.#.#.#.#######.#.#.#.###.###.#.###.#.###########
+#.#.....#.........#...#...#...#.........#.....#...#...#.#.#.#...#...#...###...#...#.......#.#.#.#...#...#...#...#.#...###...#...#...........#
+#.#####.#.###########.#########.#######.#.###.###.#.#.#.#.#.###.###.###.###.###.###.#######.#.#.#####.#.#.#######.#.#########.#############.#
+#.....#.#.........#...#...#...#.......#.#.###...#...#.#.#.#.#...###.#...#...#...#...#.....#.#.#.#.....#...#...###...#...#.....#...#...#.....#
+#####.#.#########.#.###.#.#.#.#######.#.#.#####.#####.#.#.#.#.#####.#.###.###.###.###.###.#.#.#.#.#########.#.#######.#.#.#####.#.#.#.#.#####
+#.....#...#...#...#.....#...#.###.....#...#...#...#...#.#.#.#.....#...###...#...#.#...###...#...#...........#.......#.#.#.#...#.#...#.#.....#
+#.#######.#.#.#.#############.###.#########.#.###.#.###.#.#.#####.#########.###.#.#.###############################.#.#.#.#.#.#.#####.#####.#
+#...#...#...#...#...#...#...#...#...#...#...#...#...###...#.#.....#...#...#.....#.#.#...###...#.....#...#.........#...#.#...#.#...###.#...#.#
+###.#.#.#########.#.#.#.#.#.###.###.#.#.#.#####.###########.#.#####.#.#.#.#######.#.#.#.###.#.#.###.#.#.#.#######.#####.#####.###.###.#.#.#.#
+###...#.......#...#...#.#.#...#...#...#.#.#.....#...#...###.#.....#.#...#.#.....#...#.#.#...#.#...#...#...###...#.......###...#...#...#.#...#
+#############.#.#######.#.###.###.#####.#.#.#####.#.#.#.###.#####.#.#####.#.###.#####.#.#.###.###.###########.#.###########.###.###.###.#####
+#...#...#.....#.###...#...###...#.....#...#.......#...#...#.#...#.#.#.....#.#...#...#.#.#...#...#.............#...#.......#.....#...#...#...#
+#.#.#.#.#.#####.###.#.#########.#####.###################.#.#.#.#.#.#.#####.#.###.#.#.#.###.###.#################.#.#####.#######.###.###.#.#
+#.#...#...#...#...#.#...#.....#.....#...#...#.....#.......#...#...#.#...#...#.#...#...#.....#...#...........#...#...#.....###...#.....###.#.#
+#.#########.#.###.#.###.#.###.#####.###.#.#.#.###.#.###############.###.#.###.#.#############.###.#########.#.#.#####.#######.#.#########.#.#
+#.....#...#.#...#.#...#.#...#.#...#...#.#.#.#...#...#.........###...#...#...#...#...........#.###.#.......#...#.......#...#...#.....#...#.#.#
+#####.#.#.#.###.#.###.#.###.#.#.#.###.#.#.#.###.#####.#######.###.###.#####.#####.#########.#.###.#.#####.#############.#.#.#######.#.#.#.#.#
+#.....#.#...###...###.#.....#...#.....#.#.#...#.###...#.....#.....#...#.....#.....#.......#.#...#.#.#.....#...#...###...#...#.......#.#...#.#
+#.#####.#############.#################.#.###.#.###.###.###.#######.###.#####.#####.#####.#.###.#.#.#.#####.#.#.#.###.#######.#######.#####.#
+#.....#.#...........#.......#...#...###...###.#.....#...#...#...#...###.......#...#...#...#...#.#...#.......#...#.....#.......###.....#.....#
+#####.#.#.#########.#######.#.#.#.#.#########.#######.###.###.#.#.#############.#.###.#.#####.#.#######################.#########.#####.#####
+#.....#.#.........#.........#.#.#.#.........#.....#...###.....#...#.........#...#.....#.......#.#...#...................#...#...#.....#.....#
+#.#####.#########.###########.#.#.#########.#####.#.###############.#######.#.#################.#.#.#.###################.#.#.#.#####.#####.#
+#.......#.........#.........#.#...#...#...#.....#.#.#.............#.......#.#.......#.....#...#...#...#...#...#...#...###.#.#.#.#...#.#.....#
+#########.#########.#######.#.#####.#.#.#.#####.#.#.#.###########.#######.#.#######.#.###.#.#.#########.#.#.#.#.#.#.#.###.#.#.#.#.#.#.#.#####
+###.......#...#...#.#.......#.#.....#...#.#...#.#...#.#.......#...#...#...#.........#.#...#.#.....#.....#...#...#...#.....#...#...#...#.....#
+###.#######.#.#.#.#.#.#######.#.#########.#.#.#.#####.#.#####.#.###.#.#.#############.#.###.#####.#.#######################################.#
+#...#.......#...#...#.........#.........#...#...#.....#.....#.#.#...#.#.........#...#.#...#...#...#.#.......#.....#.......#...#...#...#...#.#
+#.###.#################################.#########.#########.#.#.#.###.#########.#.#.#.###.###.#.###.#.#####.#.###.#.#####.#.#.#.#.#.#.#.#.#.#
+#.....#...#...#...#...#...#...#...#.....#.......#...#.......#...#.#...#.....###...#...###...#.#...#.#.#...#...###...#...#...#.#.#.#.#.#.#...#
+#######.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#####.#####.###.#.###########.#.###.###.###############.#.###.#.#.#.#.###########.#.#####.#.#.#.#.#.#####
+#.......#...#.#.#.#.#...#.#.#...#...#...#.#.....#...#.###.....#...#...#...#.#...#...#...###.#...#.#.#...#.#...........#.....#...#.#.#...#...#
+#.###########.#.#.#.#####.#.#########.#.#.#.#####.###.###.###.#.#####.###.#.#.#.#.#.#.#.###.###.#.#.#####.#.###############.#####.#.#####.#.#
+#...........#.#.#.#.....#.#.........#.#...#...#...#...#...#...#.....#.#...#.#.#...#.#.#.#...#...#...#.....#.#.......#.....#.....#...#...#.#.#
+###########.#.#.#.#####.#.#########.#.#######.#.###.###.###.#######.#.#.###.#.#####.#.#.#.###.#######.#####.#.#####.#.###.#####.#####.#.#.#.#
+#.....#...#.#.#.#.#...#.#.....#...#...#.......#...#.###.#...#.......#.#...#.#.....#...#.#...#.#.....#.......#.....#...###.......#.....#...#.#
+#.###.#.#.#.#.#.#.#.#.#.#####.#.#.#####.#########.#.###.#.###.#######.###.#.#####.#####.###.#.#.###.#############.###############.#########.#
+#...#.#.#...#...#...#...#...#...#.....#...#...#...#...#.#.###.......#.#...#.###...#.....###...#...#.............#...#...#.....#...#.........#
+###.#.#.#################.#.#########.###.#.#.#.#####.#.#.#########.#.#.###.###.###.#############.#############.###.#.#.#.###.#.###.#########
+#...#.#.........#.....#...#.#.......#...#...#.#.#.....#.#.#...#.....#.#...#.....#...#.....###...#.....#.......#...#...#...#...#.#...#.......#
+#.###.#########.#.###.#.###.#.#####.###.#####.#.#.#####.#.#.#.#.#####.###.#######.###.###.###.#.#####.#.#####.###.#########.###.#.###.#####.#
+#...#.#.........#.#...#...#...#...#...#.......#.#.###...#.#.#.#.....#.###.......#...#...#...#.#.......#.#.....###...........#...#.....#...#.#
+###.#.#.#########.#.#####.#####.#.###.#########.#.###.###.#.#.#####.#.#########.###.###.###.#.#########.#.###################.#########.#.#.#
+#...#...#...#...#.#...#...###...#.....###...###.#...#...#.#.#.###...#.#...#...#...#...#.#...#.........#.#.#...###...###.......#.....#...#...#
+#.#######.#.#.#.#.###.#.#####.###########.#.###.###.###.#.#.#.###.###.#.#.#.#.###.###.#.#.###########.#.#.#.#.###.#.###.#######.###.#.#######
+#.......#.#.#.#.#.#...#.#...#...........#.#...#...#...#.#.#.#...#...#...#...#.###...#...#.#.....#...#...#...#...#.#.#...#.......###.#.......#
+#######.#.#.#.#.#.#.###.#.#.###########.#.###.###.###.#.#.#.###.###.#########.#####.#####.#.###.#.#.###########.#.#.#.###.#########.#######.#
+#.......#.#...#.#.#.....#.#.###.......#.#...#.#...#...#.#.#...#...#.#.........#.....#.....#...#.#.#...#.........#.#.#.#...#...#...#.#...#...#
+#.#######.#####.#.#######.#.###.#####.#.###.#.#.###.###.#.###.###.#.#.#########.#####.#######.#.#.###.#.#########.#.#.#.###.#.#.#.#.#.#.#.###
+#...#...#.....#...###.....#.....#...#...###.#.#...#.###.#.###...#.#.#.#...#...#.....#.#...###.#.#...#.#.....###...#...#.....#...#.#.#.#.#...#
+###.#.#.#####.#######.###########.#.#######.#.###.#.###.#.#####.#.#.#.#.#.#.#.#####.#.#.#.###.#.###.#.#####.###.#################.#.#.#.###.#
+#...#.#...#...#.......#...........#.#...#...#.#...#.#...#.#...#.#...#...#.#.#.#...#.#.#.#...#.#.#...#.#...#...#.#.................#...#.#...#
+#.###.###.#.###.#######.###########.#.#.#.###.#.###.#.###.#.#.#.#########.#.#.#.#.#.#.#.###.#.#.#.###.#.#.###.#.#.#####################.#.###
+#...#...#...###.....#...#...........#.#.#...#.#.###.#...#...#.#.......#...#.#.#.#.#.#...###...#.#.###.#.#...#...#.###.................#.#...#
+###.###.###########.#.###.###########.#.###.#.#.###.###.#####.#######.#.###.#.#.#.#.###########.#.###.#.###.#####.###.###############.#.###.#
+###...#.#...........#.#...#...#.....#.#...#.#.#.#...#...###...#...#...#...#.#...#.#.....#.......#...#.#.#...#...#.....#...#...........#...#.#
+#####.#.#.###########.#.###.#.#.###.#.###.#.#.#.#.###.#####.###.#.#.#####.#.#####.#####.#.#########.#.#.#.###.#.#######.#.#.#############.#.#
+#.....#.#.....#.......#.....#.#.#...#.###.#.#.#.#...#.....#.#...#.#.....#.#...#...#.....#...#...#...#...#...#.#.....#...#.#...###...#...#...#
+#.#####.#####.#.#############.#.#.###.###.#.#.#.###.#####.#.#.###.#####.#.###.#.###.#######.#.#.#.#########.#.#####.#.###.###.###.#.#.#.#####
+#...#...#.....#...#...........#.#.#...#...#.#...#...#...#.#.#.###.....#.#.#...#...#.......#.#.#.#...#.......#.....#...###...#.....#...#.....#
+###.#.###.#######.#.###########.#.#.###.###.#####.###.#.#.#.#.#######.#.#.#.#####.#######.#.#.#.###.#.###########.#########.###############.#
+#...#...#.#.......#.........#...#.#...#...#...#...#...#.#.#.#.#.......#.#...#.....#.......#...#.....#.....#.....#.....#.....#...#...........#
+#.#####.#.#.###############.#.###.###.###.###.#.###.###.#.#.#.#.#######.#####.#####.#####################.#.###.#####.#.#####.#.#.###########
+#...#...#.#.#...............#.#...#...#...#...#...#...#...#.#.#...#...#...###.#...#.....#.......#.........#.#...#...#.#.....#.#.#.........###
+###.#.###.#.#.###############.#.###.###.###.#####.###.#####.#.###.#.#.###.###.#.#.#####.#.#####.#.#########.#.###.#.#.#####.#.#.#########.###
+#...#.#...#.#.....#.........#.#...#...#...#...###...#.#...#...#...#.#...#...#.#.#.#.....#.#.....#.........#.#...#.#...#...#...#.#...#...#...#
+#.###.#.###.#####.#.#######.#.###.###.###.###.#####.#.#.#.#####.###.###.###.#.#.#.#.#####.#.#############.#.###.#.#####.#.#####.#.#.#.#.###.#
+#...#.#.#...#.....#.###.....#.#...#...###...#.....#.#...#.....#.#...#...#...#.#.#.#.......#.....#.........#...#.#.......#...#...#.#.#.#...#.#
+###.#.#.#.###.#####.###.#####.#.###.#######.#####.#.#########.#.#.###.###.###.#.#.#############.#.###########.#.###########.#.###.#.#.###.#.#
+###.#.#.#...#.....#.#...#...#.#...#.#.......#...#.#...#.....#.#...###...#.###...#...#.....#.....#.#...#.....#.#.#.....#.....#.....#.#...#.#.#
+###.#.#.###.#####.#.#.###.#.#.###.#.#.#######.#.#.###.#.###.#.#########.#.#########.#.###.#.#####.#.#.#.###.#.#.#.###.#.###########.###.#.#.#
+#...#.#.....#...#.#.#.....#...###...#.#...#...#...###.#...#.#.#.........#...#.......#.###.#.....#...#.#.###...#.#...#.#...........#...#.#.#.#
+#.###.#######.#.#.#.#################.#.#.#.#########.###.#.#.#.###########.#.#######.###.#####.#####.#.#######.###.#.###########.###.#.#.#.#
+#...#.#.......#...#.#.................#.#.#.#.....#...#...#...#...#.....#...#...#.....#...#...#.###...#...#.....#...#.#...........###.#.#.#.#
+###.#.#.###########.#.#################.#.#.#.###.#.###.#########.#.###.#.#####.#.#####.###.#.#.###.#####.#.#####.###.#.#############.#.#.#.#
+###.#.#...#...#...#.#.........#...#...#.#...#...#.#...#.....#...#...#...#.....#.#.###...#...#.#...#.....#.#.#...#.###...#...###.....#...#...#
+###.#.###.#.#.#.#.#.#########.#.#.#.#.#.#######.#.###.#####.#.#.#####.#######.#.#.###.###.###.###.#####.#.#.#.#.#.#######.#.###.###.#########
+#...#.###...#...#...#.........#.#.#.#.#.....#...#.....#...#...#.....#...#...#.#.#.#...#...###...#.#.....#.#...#.#.........#.....#...#...#...#
+#.###.###############.#########.#.#.#.#####.#.#########.#.#########.###.#.#.#.#.#.#.###.#######.#.#.#####.#####.#################.###.#.#.#.#
+#.....#...#...........#.......#.#.#.#...#...#...#...#...#.#.........#...#.#.#.#...#...#.###...#...#.#.....#.....#...#...........#.....#...#.#
+#######.#.#.###########.#####.#.#.#.###.#.#####.#.#.#.###.#.#########.###.#.#.#######.#.###.#.#####.#.#####.#####.#.#.#########.###########.#
+#.....#.#.#...#...#...#.###...#.#.#.#...#.#.....#.#.#...#.#.....#...#.....#.#.#.......#.....#.#.....#.....#...#...#.#.........#...#.........#
+#.###.#.#.###.#.#.#.#.#.###.###.#.#.#.###.#.#####.#.###.#.#####.#.#.#######.#.#.#############.#.#########.###.#.###.#########.###.#.#########
+#...#...#.....#.#.#.#.#.#...#...#.#.#...#.#.#...#.#.#...#.#...#...#.......#.#.#...#...#...#...#...#...#...#...#.#...#...#...#...#.#.........#
+###.###########.#.#.#.#.#.###.###.#.###.#.#.#.#.#.#.#.###.#.#.###########.#.#.###.#.#.#.#.#.#####.#.#.#.###.###.#.###.#.#.#.###.#.#########.#
+###.............#...#...#.....###...###...#...#...#...###...#.............#...###...#...#...#####...#...###.....#.....#...#.....#...........#
+#############################################################################################################################################

Inputs/Day21.txt

@@ -0,0 +1,5 @@
+029A
+980A
+179A
+456A
+379A

Inputs/Day24.txt

@@ -0,0 +1,313 @@
+x00: 1
+x01: 0
+x02: 1
+x03: 1
+x04: 0
+x05: 0
+x06: 1
+x07: 1
+x08: 0
+x09: 1
+x10: 1
+x11: 1
+x12: 1
+x13: 1
+x14: 0
+x15: 1
+x16: 0
+x17: 1
+x18: 0
+x19: 1
+x20: 1
+x21: 0
+x22: 0
+x23: 0
+x24: 1
+x25: 1
+x26: 1
+x27: 0
+x28: 1
+x29: 1
+x30: 1
+x31: 0
+x32: 0
+x33: 1
+x34: 1
+x35: 0
+x36: 0
+x37: 0
+x38: 1
+x39: 0
+x40: 0
+x41: 0
+x42: 0
+x43: 1
+x44: 1
+y00: 1
+y01: 0
+y02: 0
+y03: 1
+y04: 1
+y05: 0
+y06: 0
+y07: 0
+y08: 0
+y09: 0
+y10: 0
+y11: 1
+y12: 0
+y13: 0
+y14: 0
+y15: 0
+y16: 1
+y17: 0
+y18: 0
+y19: 1
+y20: 0
+y21: 1
+y22: 0
+y23: 1
+y24: 0
+y25: 0
+y26: 1
+y27: 0
+y28: 0
+y29: 1
+y30: 0
+y31: 0
+y32: 0
+y33: 1
+y34: 0
+y35: 0
+y36: 0
+y37: 1
+y38: 0
+y39: 0
+y40: 1
+y41: 0
+y42: 1
+y43: 1
+y44: 1
+
+x44 XOR y44 -> drc
+phq OR frm -> hjs
+vdh AND nwn -> gqd
+y40 XOR x40 -> vkn
+x21 XOR y21 -> cnb
+cnb AND wmb -> vvk
+dfb XOR bfn -> hbk
+bhd XOR mmh -> z06
+fkc XOR bwj -> z22
+gnj AND jfw -> spq
+dwh AND kqn -> fhp
+x19 AND y19 -> kkg
+drc XOR qqt -> z44
+fkc AND bwj -> jbb
+y32 XOR x32 -> qwt
+y37 AND x37 -> kgg
+x07 AND y07 -> dqn
+dsp AND bvp -> hff
+pmv OR pkn -> wmt
+cjf OR pfk -> z45
+hgq XOR phb -> z27
+qnq OR dpc -> djp
+x32 AND y32 -> nbb
+qwt AND jqm -> fdk
+x18 XOR y18 -> grp
+vkf OR hdm -> kqn
+cqv AND jss -> bwd
+x00 AND y00 -> jfw
+cjb XOR srm -> z19
+jss XOR cqv -> z35
+ntt OR spq -> ndd
+cqm XOR qqj -> z43
+x01 AND y01 -> ntt
+y14 XOR x14 -> dfb
+nbk XOR wrk -> z05
+dvw AND rpg -> z23
+vvc OR kcv -> qqj
+bqc XOR fwr -> z26
+dwh XOR kqn -> z41
+x15 XOR y15 -> bkb
+rjm XOR gjr -> z24
+x22 XOR y22 -> bwj
+y22 AND x22 -> hpj
+x08 XOR y08 -> hnf
+y27 AND x27 -> frm
+wrw OR swr -> fds
+gtm AND rmt -> mkv
+kdh AND qvq -> ghr
+fgv AND mfm -> kcv
+hnf AND gqs -> pmv
+kkg OR qvs -> vdh
+fdk OR nbb -> rmt
+y29 AND x29 -> cwd
+hjk OR bts -> vkg
+vtk AND npm -> tqb
+dvw XOR rpg -> dbb
+y39 XOR x39 -> mnm
+y05 XOR x05 -> wrk
+djd AND fds -> dqt
+tvh OR sqm -> npm
+cdr XOR cmt -> z10
+x28 XOR y28 -> hgd
+x33 XOR y33 -> gtm
+mnm XOR vhv -> z39
+fbv XOR bwg -> z38
+hqs AND nhr -> vbt
+kth OR qcp -> hgq
+wjj OR scs -> bfn
+bkv OR vvk -> fkc
+cmt AND cdr -> pph
+dqt OR gqb -> bqc
+y35 XOR x35 -> jss
+vkb OR krd -> cdr
+mqf AND cvh -> trj
+x36 XOR y36 -> dsp
+y41 XOR x41 -> dwh
+y38 XOR x38 -> bwg
+ghr OR tpc -> jqm
+ckn XOR hqq -> z07
+vkn AND vkg -> vkf
+y28 AND x28 -> wkc
+x31 XOR y31 -> qvq
+rjm AND gjr -> swr
+gcb OR dbb -> rjm
+y18 AND x18 -> z18
+y24 AND x24 -> wrw
+x17 XOR y17 -> kbh
+y24 XOR x24 -> gjr
+x26 XOR y26 -> fwr
+y43 AND x43 -> bvm
+y15 AND x15 -> sbt
+y12 XOR x12 -> fvh
+kvn OR ffb -> cjb
+y31 AND x31 -> tpc
+y37 XOR x37 -> bnh
+y11 AND x11 -> scv
+hgd AND hjs -> phr
+jfw XOR gnj -> z01
+fvh XOR sfk -> z12
+fds XOR djd -> z25
+qwt XOR jqm -> z32
+bvp XOR dsp -> z36
+phr OR wkc -> jdq
+y07 XOR x07 -> hqq
+y43 XOR x43 -> cqm
+bnh XOR kss -> z37
+trg OR vbt -> kdh
+cwd OR pkc -> nhr
+y19 XOR x19 -> srm
+dkd AND jdq -> pkc
+wrk AND nbk -> fnk
+hjs XOR hgd -> z28
+rnt AND qbs -> rcp
+djp XOR mft -> z03
+cht OR mkv -> mqf
+hbk XOR bkb -> z15
+x44 AND y44 -> pfk
+x26 AND y26 -> qcp
+ndd XOR jgw -> z02
+x06 AND y06 -> dhs
+ckn AND hqq -> cpt
+y13 AND x13 -> wjj
+x10 AND y10 -> tvr
+ffr OR gqd -> wmb
+y09 XOR x09 -> tjb
+nhr XOR hqs -> z30
+hgq AND phb -> phq
+x00 XOR y00 -> z00
+y16 AND x16 -> prt
+dqn OR cpt -> gqs
+x23 AND y23 -> gcb
+mft AND djp -> tvh
+bkb AND hbk -> qtw
+kfk AND chk -> vgb
+vhv AND mnm -> hjk
+y42 XOR x42 -> mfm
+x25 XOR y25 -> djd
+fgv XOR mfm -> z42
+grp XOR fgr -> kvn
+x16 XOR y16 -> chk
+x09 AND y09 -> krd
+cqb OR rmg -> mqm
+y30 XOR x30 -> hqs
+kss AND bnh -> dvf
+y11 XOR x11 -> rnt
+x04 AND y04 -> ptm
+y13 XOR x13 -> cbr
+rnt XOR qbs -> z11
+hff OR fjf -> kss
+x25 AND y25 -> gqb
+kdh XOR qvq -> z31
+y06 XOR x06 -> mmh
+cnb XOR wmb -> z21
+y02 XOR x02 -> jgw
+x17 AND y17 -> hkn
+y34 AND x34 -> cvh
+x27 XOR y27 -> phb
+x42 AND y42 -> vvc
+x03 XOR y03 -> mft
+y35 AND x35 -> nvg
+x10 XOR y10 -> cmt
+y20 AND x20 -> ffr
+x30 AND y30 -> trg
+ptm OR tqb -> nbk
+bfn AND dfb -> sjr
+jgw AND ndd -> qnq
+y39 AND x39 -> bts
+y38 AND x38 -> knq
+npm XOR vtk -> z04
+prt OR vgb -> jqc
+kfk XOR chk -> z16
+rvd OR dhs -> ckn
+fnk OR wkv -> bhd
+y03 AND x03 -> sqm
+x08 AND y08 -> pkn
+y02 AND x02 -> dpc
+bwg AND fbv -> pdw
+mqf XOR cvh -> z34
+tjb AND wmt -> vkb
+jdq XOR dkd -> z29
+x34 XOR y34 -> tfn
+y21 AND x21 -> bkv
+tfn OR trj -> cqv
+fgr AND grp -> ffb
+bwd OR nvg -> bvp
+cjv OR hkn -> fgr
+fhp OR rnc -> fgv
+sjr OR tck -> z14
+vkn XOR vkg -> z40
+kbh XOR jqc -> z17
+kgg OR dvf -> fbv
+tjb XOR wmt -> z09
+tvr OR pph -> qbs
+qqj AND cqm -> gsg
+pdw OR knq -> vhv
+gqs XOR hnf -> z08
+y20 XOR x20 -> nwn
+kbh AND jqc -> cjv
+bqc AND fwr -> kth
+rcp OR scv -> sfk
+sbt OR qtw -> kfk
+bhd AND mmh -> rvd
+nwn XOR vdh -> z20
+y29 XOR x29 -> dkd
+y23 XOR x23 -> rpg
+jbb OR hpj -> dvw
+cbr XOR mqm -> z13
+y33 AND x33 -> cht
+y12 AND x12 -> rmg
+mqm AND cbr -> scs
+sfk AND fvh -> cqb
+y14 AND x14 -> tck
+x04 XOR y04 -> vtk
+y05 AND x05 -> wkv
+rmt XOR gtm -> z33
+y01 XOR x01 -> gnj
+srm AND cjb -> qvs
+x36 AND y36 -> fjf
+drc AND qqt -> cjf
+y40 AND x40 -> hdm
+y41 AND x41 -> rnc
+gsg OR bvm -> qqt