Day17 2021 in nim

2019/build.gradle.kts

@@ -0,0 +1,14 @@
+plugins {
+    id("java-convention")
+}
+
+dependencies {
+    implementation(project(":utils"))
+
+    annotationProcessor(Libs.Micronaut.processor)
+
+    implementation(Libs.eclipseCollections)
+
+    testImplementation(Libs.Jmh.core)
+    testAnnotationProcessor(Libs.Jmh.processor)
+}

2019/src/main/java/be/vandewalleh/aoc/Day01.java

@@ -0,0 +1,47 @@
+package be.vandewalleh.aoc;
+
+import be.vandewalleh.aoc.utils.factory.Days;
+import be.vandewalleh.aoc.utils.input.Day;
+import be.vandewalleh.aoc.utils.input.Lines;
+
+@Day(1)
+public class Day01 {
+
+    public static void main(String[] args) {
+        var day = Days.createDay(Day01.class);
+        System.out.println(day.part1());
+        System.out.println(day.part2());
+    }
+
+    private final int[] input;
+
+    public Day01(@Lines int[] input) {
+        this.input = input;
+    }
+
+    private int fuel(int mass) {
+        return (mass / 3) - 2;
+    }
+
+    public int part1() {
+        var total = 0;
+        for (var mass : input) {
+            total += fuel(mass);
+        }
+        return total;
+    }
+
+    public int part2() {
+        var total = 0;
+        for (var mass : input) {
+            int fuel = fuel(mass);
+            total += fuel;
+            while (true) {
+                fuel = fuel(fuel);
+                if (fuel <= 0) break;
+                total += fuel;
+            }
+        }
+        return total;
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/Day02.java

@@ -0,0 +1,43 @@
+package be.vandewalleh.aoc;
+
+import be.vandewalleh.aoc.intcode.IntCodeInterpreter;
+import be.vandewalleh.aoc.utils.factory.Days;
+import be.vandewalleh.aoc.utils.input.Csv;
+import be.vandewalleh.aoc.utils.input.Day;
+
+@Day(2)
+public class Day02 {
+
+    public static void main(String[] args) {
+        var day = Days.createDay(Day02.class);
+        System.out.println(day.part1());
+        System.out.println(day.part2());
+    }
+
+    private final int[] input;
+
+    public Day02(@Csv int[] input) {
+        this.input = input;
+    }
+
+    private long runInterpreterWith(int noun, int verb) {
+        var interpreter = new IntCodeInterpreter(input);
+        interpreter.setNoun(noun);
+        interpreter.setVerb(verb);
+        interpreter.run();
+        return interpreter.getOutput();
+    }
+
+    public long part1() {
+        return runInterpreterWith(12, 2);
+    }
+
+    public int part2() {
+        for (var noun = 0; noun < 99; noun++) {
+            for (var verb = 0; verb < 99; verb++) {
+                if (runInterpreterWith(noun, verb) == 19690720L) return 100 * noun + verb;
+            }
+        }
+        return -1;
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/Day03.java

@@ -0,0 +1,63 @@
+package be.vandewalleh.aoc;
+
+import be.vandewalleh.aoc.geometry.Direction2D;
+import be.vandewalleh.aoc.geometry.Point2D;
+import be.vandewalleh.aoc.utils.factory.Days;
+import be.vandewalleh.aoc.utils.input.Day;
+import be.vandewalleh.aoc.utils.input.Lines;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+@Day(3)
+public class Day03 {
+
+    public static void main(String[] args) {
+        var day = Days.createDay(Day03.class);
+        System.out.println(day.part1());
+        System.out.println(day.part2());
+    }
+
+    private final String[] wireA;
+    private final String[] wireB;
+
+    public Day03(@Lines List<String> input) {
+        this.wireA = input.get(0).split(",");
+        this.wireB = input.get(1).split(",");
+    }
+
+    private List<Point2D> path(String[] wire) {
+        var points = new ArrayList<Point2D>();
+        var point = Point2D.origin;
+        for (var section : wire) {
+            var direction = Direction2D.from(section.charAt(0));
+            var count = Integer.parseInt(section.substring(1));
+            for (int i = 0; i < count; i++) {
+                point = point.translate(direction.point);
+                points.add(point);
+            }
+        }
+        return points;
+    }
+
+    private int part1() {
+        var pathA = path(wireA);
+        var pathB = path(wireB);
+
+        var intersections = new HashSet<>(pathA);
+        intersections.retainAll(pathB);
+
+        return intersections.stream().mapToInt(Point2D::manhattanDistance).min().orElse(-1);
+    }
+
+    private int part2() {
+        var pathA = path(wireA);
+        var pathB = path(wireB);
+
+        var intersections = new HashSet<>(pathA);
+        intersections.retainAll(pathB);
+
+        return intersections.stream().mapToInt(p -> pathA.indexOf(p) + pathB.indexOf(p) + 2).min().orElse(-1);
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/Day04.java

@@ -0,0 +1,80 @@
+package be.vandewalleh.aoc;
+
+import be.vandewalleh.aoc.utils.factory.Days;
+import be.vandewalleh.aoc.utils.input.Day;
+import be.vandewalleh.aoc.utils.input.Text;
+
+import java.util.Arrays;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+@Day(4)
+public class Day04 {
+
+    public static void main(String[] args) {
+        var day = Days.createDay(Day04.class);
+        System.out.println(day.part1());
+        System.out.println(day.part2());
+    }
+
+    private final int min;
+    private final int max;
+
+    public Day04(@Text String input) {
+        var spl = input.split("-", 2);
+        min = Integer.parseInt(spl[0]);
+        max = Integer.parseInt(spl[1]);
+    }
+
+    private boolean isNotDecreasing(int[] ints) {
+        for (int i = 0; i < 5; i++) {
+            int a = ints[i], b = ints[i + 1];
+            if (b < a) return false;
+        }
+        return true;
+    }
+
+    private boolean hasPair(int[] ints) {
+        for (int i = 0; i < 5; i++) {
+            int a = ints[i], b = ints[i + 1];
+            if (a == b) return true;
+        }
+        return false;
+    }
+
+    private boolean hasGroup(int[] ints) {
+        var occurrences = new int[10];
+        for (int i = 0; i < 5; i++) {
+            int a = ints[i], b = ints[i + 1];
+            if (a == b) occurrences[a]++;
+        }
+        return Arrays.stream(occurrences).anyMatch(e -> e == 1);
+    }
+
+    private Stream<int[]> intStream() {
+        return IntStream.rangeClosed(min, max)
+            .mapToObj(String::valueOf)
+            .map(String::toCharArray)
+            .map(e -> {
+                var ints = new int[6];
+                for (int i = 0; i < 6; i++) {
+                    ints[i] = Integer.parseInt(String.valueOf(e[i]));
+                }
+                return ints;
+            });
+    }
+
+    private long part1() {
+        return intStream()
+            .filter(this::isNotDecreasing)
+            .filter(this::hasPair)
+            .count();
+    }
+
+    private long part2() {
+        return intStream()
+            .filter(this::isNotDecreasing)
+            .filter(this::hasGroup)
+            .count();
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/Day05.java

@@ -0,0 +1,36 @@
+package be.vandewalleh.aoc;
+
+import be.vandewalleh.aoc.intcode.IntCodeInterpreter;
+import be.vandewalleh.aoc.utils.factory.Days;
+import be.vandewalleh.aoc.utils.input.Csv;
+import be.vandewalleh.aoc.utils.input.Day;
+
+@Day(5)
+public class Day05 {
+
+    public static void main(String[] args) {
+        var day = Days.createDay(Day05.class);
+        System.out.println(day.part1());
+        System.out.println(day.part2());
+    }
+
+    private final int[] input;
+
+    public Day05(@Csv int[] input) {
+        this.input = input;
+    }
+
+    private Long part1() {
+        var interpreter = new IntCodeInterpreter(input);
+        interpreter.setInput(1);
+        interpreter.run();
+        return interpreter.getOutputs().peek();
+    }
+
+    private Long part2() {
+        var interpreter = new IntCodeInterpreter(input);
+        interpreter.setInput(5);
+        interpreter.run();
+        return interpreter.getOutputs().peek();
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/Day06.java

@@ -0,0 +1,80 @@
+package be.vandewalleh.aoc;
+
+import be.vandewalleh.aoc.utils.factory.Days;
+import be.vandewalleh.aoc.utils.input.Day;
+import be.vandewalleh.aoc.utils.input.Lines;
+
+import java.util.*;
+
+@Day(6)
+public class Day06 {
+
+    public static void main(String[] args) {
+        var day = Days.createDay(Day06.class);
+        System.out.println(day.part1());
+        System.out.println(day.part2());
+    }
+
+    private final List<String> input;
+
+    public Day06(@Lines List<String> input) {
+        this.input = input;
+    }
+
+    private final Map<String, String> reverseOrbits = new HashMap<>();
+
+    private int countDirectOrbits() {
+        return reverseOrbits.size();
+    }
+
+    private int countIndirectOrbits() {
+        var count = 0;
+        for (var key : reverseOrbits.keySet()) {
+            count += countIndirectOrbits(key);
+        }
+        return count;
+    }
+
+    private int countIndirectOrbits(String key) {
+        var count = 0;
+        var currentKey = reverseOrbits.get(key);
+        while (currentKey != null) {
+            currentKey = reverseOrbits.get(currentKey);
+            if (currentKey != null) count++;
+            else return count;
+        }
+        return -1;
+    }
+
+    private List<String> pathToCom(String key) {
+        var path = new ArrayList<String>();
+        var currentKey = reverseOrbits.get(key);
+        path.add(currentKey);
+        while (currentKey != null) {
+            currentKey = reverseOrbits.get(currentKey);
+            if (currentKey == null) return path;
+            else path.add(currentKey);
+        }
+        return path;
+    }
+
+    private int part1() {
+        for (var line : input) {
+            var split = line.split("\\)");
+            reverseOrbits.put(split[1], split[0]);
+        }
+        return countDirectOrbits() + countIndirectOrbits();
+    }
+
+    private int part2() {
+        var sanPath = pathToCom("SAN");
+        var youPath = pathToCom("YOU");
+
+        var common = new LinkedHashSet<>(sanPath);
+        common.retainAll(youPath);
+
+        String closestCommon = (String) common.toArray()[0];
+        return sanPath.indexOf(closestCommon) + youPath.indexOf(closestCommon);
+    }
+
+}

2019/src/main/java/be/vandewalleh/aoc/geometry/Direction2D.java

@@ -0,0 +1,29 @@
+package be.vandewalleh.aoc.geometry;
+
+public enum Direction2D {
+    Up(0, -1), Down(0, 1), Right(1, 0), Left(-1, 0);
+
+    public final Point2D point;
+
+    Direction2D(int x, int y) {
+        this.point = new Point2D(x, y);
+    }
+
+    public static Direction2D from(char direction) {
+        switch (direction) {
+            case 'U' -> {
+                return Direction2D.Up;
+            }
+            case 'D' -> {
+                return Direction2D.Down;
+            }
+            case 'R' -> {
+                return Direction2D.Right;
+            }
+            case 'L' -> {
+                return Direction2D.Left;
+            }
+            default -> throw new IllegalArgumentException("Unexpected value: " + direction);
+        }
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/geometry/Point2D.java

@@ -0,0 +1,13 @@
+package be.vandewalleh.aoc.geometry;
+
+public record Point2D(int x, int y) {
+    public static Point2D origin = new Point2D(0, 0);
+
+    public int manhattanDistance() {
+        return Math.abs(x) + Math.abs(y);
+    }
+
+    public Point2D translate(Point2D other) {
+        return new Point2D(this.x + other.x, this.y + other.y);
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/intcode/IntCodeInterpreter.java

@@ -0,0 +1,115 @@
+package be.vandewalleh.aoc.intcode;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Deque;
+
+public class IntCodeInterpreter {
+    private final Deque<Long> outputs = new ArrayDeque<>();
+    private final long[] memory;
+    private long input;
+
+    public IntCodeInterpreter(int[] memory) {
+        this.memory = Arrays.stream(memory).asLongStream().toArray();
+    }
+
+    public void setNoun(long noun) {
+        memory[1] = noun;
+    }
+
+    public void setVerb(long verb) {
+        memory[2] = verb;
+    }
+
+    public void setInput(long input) {
+        this.input = input;
+    }
+
+    public long getOutput() {
+        return memory[0];
+    }
+
+    // private ?
+    public Deque<Long> getOutputs() {
+        return outputs;
+    }
+
+    private long readArgument(Mode mode, long param) {
+        switch (mode) {
+            case Positional -> {
+                return memory[(int) param];
+            }
+            case Immediate -> {
+                return param;
+            }
+            default -> throw new IllegalArgumentException();
+        }
+    }
+
+    private void writeArgument(long param, long value) {
+        memory[(int) param] = value;
+    }
+
+    private Mode[] modes(long instruction) {
+        var str = String.format("%5d", instruction).replace(' ', '0');
+        return new Mode[]{
+            Mode.of(str.charAt(2)),
+            Mode.of(str.charAt(1)),
+            Mode.of(str.charAt(0))
+        };
+    }
+
+    public void run() {
+        var pointer = 0;
+
+        loop:
+        while (true) {
+            var jumped = false;
+            var instruction = memory[pointer];
+            var opCode = OpCode.from(((int) instruction) % 100);
+            var args = Arrays.copyOfRange(memory, pointer + 1, pointer + opCode.params + 1);
+            var modes = modes(instruction);
+            switch (opCode) {
+                case Add -> {
+                    var value = readArgument(modes[0], args[0]) + readArgument(modes[1], args[1]);
+                    writeArgument(args[2], value);
+                }
+                case Multiply -> {
+                    var value = readArgument(modes[0], args[0]) * readArgument(modes[1], args[1]);
+                    writeArgument(args[2], value);
+                }
+                case In -> {
+                    writeArgument(args[0], input);
+                }
+                case Out -> {
+                    outputs.push(readArgument(modes[0], args[0]));
+                }
+                case JumpIfTrue -> {
+                    if (readArgument(modes[0], args[0]) != 0) {
+                        pointer = (int) readArgument(modes[1], args[1]);
+                        jumped = true;
+                    }
+                }
+                case JumpIfFalse -> {
+                    if (readArgument(modes[0], args[0]) == 0) {
+                        pointer = (int) readArgument(modes[1], args[1]);
+                        jumped = true;
+                    }
+                }
+                case LessThan -> {
+                    var value = readArgument(modes[0], args[0]) < readArgument(modes[1], args[1]) ? 1 : 0;
+                    writeArgument(args[2], value);
+                }
+                case Equals -> {
+                    var value = readArgument(modes[0], args[0]) == readArgument(modes[1], args[1]) ? 1 : 0;
+                    writeArgument(args[2], value);
+                }
+                case Halt -> {
+                    break loop;
+                }
+
+            }
+            if (!jumped) pointer += opCode.params + 1;
+        }
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/intcode/Mode.java

@@ -0,0 +1,11 @@
+package be.vandewalleh.aoc.intcode;
+
+public enum Mode {
+    Positional, Immediate;
+
+    public static Mode of(char representation) {
+        if (representation == '0') return Mode.Positional;
+        else if (representation == '1') return Mode.Immediate;
+        else throw new IllegalArgumentException("Unsupported Mode " + representation);
+    }
+}

2019/src/main/java/be/vandewalleh/aoc/intcode/OpCode.java

@@ -0,0 +1,29 @@
+package be.vandewalleh.aoc.intcode;
+
+public enum OpCode {
+    Add(1, 3),
+    Multiply(2, 3),
+    Halt(99, 0),
+    In(3, 1),
+    Out(4, 1),
+    JumpIfTrue(5, 2),
+    JumpIfFalse(6, 2),
+    LessThan(7, 3),
+    Equals(8, 3),
+    ;
+
+    public final int value;
+    public final int params;
+
+    OpCode(int value, int params) {
+        this.value = value;
+        this.params = params;
+    }
+
+    public static OpCode from(int value) {
+        for (OpCode opCode : OpCode.values()) {
+            if (opCode.value == value) return opCode;
+        }
+        throw new IllegalArgumentException("Unsupported OpCode " + value);
+    }
+}

2019/src/main/resources/day01.txt

@@ -0,0 +1,100 @@
+132791
+78272
+114679
+60602
+59038
+69747
+61672
+147972
+92618
+70186
+125826
+61803
+78112
+124864
+58441
+113062
+105389
+125983
+90716
+75544
+148451
+73739
+127762
+146660
+128747
+148129
+138635
+80095
+60241
+145455
+98730
+59139
+146828
+113550
+91682
+107415
+129207
+147635
+104583
+102245
+73446
+148657
+96364
+52033
+69964
+63609
+98207
+73401
+65511
+115034
+126179
+96664
+85394
+128472
+79017
+93222
+55267
+102446
+133150
+148985
+95325
+57713
+77370
+60879
+111977
+99362
+91581
+55201
+137670
+127159
+128324
+77217
+86378
+112847
+108265
+80355
+75650
+106222
+67793
+113891
+74508
+139463
+69972
+122753
+135854
+127770
+101085
+98304
+61451
+146719
+61225
+60468
+83613
+137436
+126303
+78759
+70081
+110671
+113234
+111563

2019/src/main/resources/day02.txt

@@ -0,0 +1 @@
+1,0,0,3,1,1,2,3,1,3,4,3,1,5,0,3,2,6,1,19,1,5,19,23,2,6,23,27,1,27,5,31,2,9,31,35,1,5,35,39,2,6,39,43,2,6,43,47,1,5,47,51,2,9,51,55,1,5,55,59,1,10,59,63,1,63,6,67,1,9,67,71,1,71,6,75,1,75,13,79,2,79,13,83,2,9,83,87,1,87,5,91,1,9,91,95,2,10,95,99,1,5,99,103,1,103,9,107,1,13,107,111,2,111,10,115,1,115,5,119,2,13,119,123,1,9,123,127,1,5,127,131,2,131,6,135,1,135,5,139,1,139,6,143,1,143,6,147,1,2,147,151,1,151,5,0,99,2,14,0,0

2019/src/main/resources/day03.txt

@@ -0,0 +1,2 @@
+R1000,U371,R195,U136,R804,U805,L450,U211,R768,U768,L548,U354,L736,U431,L152,U658,L670,D262,L277,U136,L290,U939,R501,U550,L931,D839,R335,D492,L25,U80,R878,U355,R653,U186,R423,D485,L793,D259,L739,U679,R508,D269,R432,D761,R97,D461,L675,U958,L58,U348,L719,D271,R144,U849,R384,U72,L84,U493,R947,U30,L356,D442,R327,U646,R825,U718,L329,D173,L949,D345,L971,D830,L93,U506,R245,D376,R322,D105,L604,D60,R298,D959,L165,D423,R180,D527,R956,D944,R785,U641,L794,D182,R975,D719,L166,U974,L224,U243,L666,U706,R796,D600,L856,D913,L988,D993,L259,U351,R487,D424,L335,U910,L437,D180,R621,D3,R878,D188,R254,D393,L727,U829,R352,U958,L327,D158,L854,D17,R143,D454,R889,D265,L345,U784,R35,D129,R77,U117,R951,D980,L866,U646,R242,D603,L562,U727,L496,U328,L380,D504,R644,U803,L530,D546,R328,D373,L489,U454,R74,D908,R366,U94,R604,D482,L573,D27,R943,U497,L782,D267,L391,U49,R528,D58,R155,D529,R227,D998,R558,D891,R224,U843,R512,U34,R92,U404,R752,U946,L338,D880,L513,D28,L856,D444,L187,U532,L187,U669,L306,U259,R287,D442,R478,U576,R702,U336,L305,U701,L754,D277,R760,D863,L717,U196,L221,U101,L334,D156,L961,D810,L67,D716,L457,D44,L505,D724,R716,D660,L36,D338,R54,U424,R730,U18,L65,D133,R149,U374,R356,D989,R519,U593,L444,D270,R328,U167,L748,D797,L434,U751,R444,D71,R158,D530,L630,U147,R909,D994,L957,U521,L644,D579,R673,U191,R935,U237,R600,D321,L671,U961,L884,U378,R534,D46,R275,U845,R571,U245,L507,U273,R995,U408,L14,D799,L955,D534,R579,D94,R705,D391,R469,D381,R620,U162,R907,D826,R824,U167,L734,U922,L484
+L1007,D620,R853,U77,L13,U473,L253,D410,R897,U464,L862,U281,L650,D470,R87,D204,L896,U670,L864,D950,L75,D320,R901,D785,L653,D225,L857,U616,L143,U940,L664,U131,L547,D745,R636,U569,L50,U454,R288,D254,L36,U377,L609,U929,L714,U85,L939,U923,L566,D280,R243,U948,R447,D7,R908,D151,R824,D432,R34,D81,L458,U745,L420,D982,L625,U910,L729,D274,R910,U322,L984,D88,L700,D349,L932,U510,R625,U88,L252,U785,L378,D101,R299,U66,L476,U696,R236,D46,R590,U157,R461,U305,L269,D487,L676,U467,R319,D524,R75,U65,L478,U861,L238,D716,R888,D12,L184,D578,R266,D226,L656,D172,L752,U124,L831,U810,L663,U538,R417,D770,L359,U1,R12,U791,L332,U272,R574,D942,L857,U447,R310,U342,L713,D258,R590,D585,R129,D115,R832,D967,R981,D159,R864,U423,R268,U519,L52,D493,R445,D657,R885,U166,R155,D264,R51,D632,R525,D875,R617,U898,L556,D386,L143,U278,L767,D389,R821,U869,R286,D90,R289,U54,R15,D764,R46,D674,R983,U49,R959,U779,R958,D247,R483,U156,L18,U12,L178,U540,L499,U487,L544,D336,R814,U267,R145,D135,L920,D902,L933,D507,L997,U361,L577,U425,L773,D782,R117,U851,R998,U503,R902,U781,L161,U98,L653,U633,L91,U629,L138,D19,R147,D756,R364,D529,L764,U913,L118,U856,R774,D621,R151,U154,R737,D960,R86,U458,R991,D481,R560,D858,R223,D6,R931,D301,R552,D797,R284,U368,L967,D686,R940,U410,R137,D156,L6,U643,L445,D999,R888,D277,L852,U210,L777,D36,R103,D652,R120,D67,L642,D527,R913,D858,R69,D433,R864,U75,L531,U456,L664,D452,R801,U851,L824,D278,L526,U133,R200,U768,R15,U393,R982,U287,L38,D114,R86,U299,L819,D891,R379,D601,L244

2019/src/main/resources/day04.txt

@@ -0,0 +1 @@
+272091-815432

2019/src/main/resources/day05.txt

@@ -0,0 +1 @@
+3,225,1,225,6,6,1100,1,238,225,104,0,1101,11,91,225,1002,121,77,224,101,-6314,224,224,4,224,1002,223,8,223,1001,224,3,224,1,223,224,223,1102,74,62,225,1102,82,7,224,1001,224,-574,224,4,224,102,8,223,223,1001,224,3,224,1,224,223,223,1101,28,67,225,1102,42,15,225,2,196,96,224,101,-4446,224,224,4,224,102,8,223,223,101,6,224,224,1,223,224,223,1101,86,57,225,1,148,69,224,1001,224,-77,224,4,224,102,8,223,223,1001,224,2,224,1,223,224,223,1101,82,83,225,101,87,14,224,1001,224,-178,224,4,224,1002,223,8,223,101,7,224,224,1,223,224,223,1101,38,35,225,102,31,65,224,1001,224,-868,224,4,224,1002,223,8,223,1001,224,5,224,1,223,224,223,1101,57,27,224,1001,224,-84,224,4,224,102,8,223,223,1001,224,7,224,1,223,224,223,1101,61,78,225,1001,40,27,224,101,-89,224,224,4,224,1002,223,8,223,1001,224,1,224,1,224,223,223,4,223,99,0,0,0,677,0,0,0,0,0,0,0,0,0,0,0,1105,0,99999,1105,227,247,1105,1,99999,1005,227,99999,1005,0,256,1105,1,99999,1106,227,99999,1106,0,265,1105,1,99999,1006,0,99999,1006,227,274,1105,1,99999,1105,1,280,1105,1,99999,1,225,225,225,1101,294,0,0,105,1,0,1105,1,99999,1106,0,300,1105,1,99999,1,225,225,225,1101,314,0,0,106,0,0,1105,1,99999,1008,677,226,224,1002,223,2,223,1006,224,329,101,1,223,223,8,226,677,224,102,2,223,223,1005,224,344,101,1,223,223,1107,226,677,224,102,2,223,223,1006,224,359,101,1,223,223,1007,226,226,224,102,2,223,223,1006,224,374,101,1,223,223,7,677,677,224,102,2,223,223,1005,224,389,1001,223,1,223,108,677,677,224,1002,223,2,223,1005,224,404,101,1,223,223,1008,226,226,224,102,2,223,223,1005,224,419,1001,223,1,223,1107,677,226,224,102,2,223,223,1005,224,434,1001,223,1,223,1108,677,677,224,102,2,223,223,1006,224,449,1001,223,1,223,7,226,677,224,102,2,223,223,1005,224,464,101,1,223,223,1008,677,677,224,102,2,223,223,1005,224,479,101,1,223,223,1007,226,677,224,1002,223,2,223,1006,224,494,101,1,223,223,8,677,226,224,1002,223,2,223,1005,224,509,101,1,223,223,1007,677,677,224,1002,223,2,223,1006,224,524,101,1,223,223,107,226,226,224,102,2,223,223,1006,224,539,101,1,223,223,107,226,677,224,102,2,223,223,1005,224,554,1001,223,1,223,7,677,226,224,102,2,223,223,1006,224,569,1001,223,1,223,107,677,677,224,1002,223,2,223,1005,224,584,101,1,223,223,1107,677,677,224,102,2,223,223,1005,224,599,101,1,223,223,1108,226,677,224,102,2,223,223,1006,224,614,101,1,223,223,8,226,226,224,102,2,223,223,1006,224,629,101,1,223,223,108,226,677,224,102,2,223,223,1005,224,644,1001,223,1,223,108,226,226,224,102,2,223,223,1005,224,659,101,1,223,223,1108,677,226,224,102,2,223,223,1006,224,674,1001,223,1,223,4,223,99,226

2020/build.gradle.kts

@@ -0,0 +1,18 @@
+plugins {
+    id("kotlin-convention")
+    kotlin("kapt")
+}
+
+dependencies {
+    implementation(project(":utils"))
+
+    kapt(Libs.Micronaut.processor)
+
+    implementation(Libs.Slf4J.api)
+    runtimeOnly(Libs.Slf4J.simple)
+
+    implementation(Libs.eclipseCollections)
+
+    testImplementation(Libs.Jmh.core)
+    kaptTest(Libs.Jmh.processor)
+}

2020/src/main/kotlin/Day01.kt

@@ -1,14 +1,10 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
 
 @Day(1)
-class Day01(@Lines input: Input<IntArray>) {
-    private val items = input.value
-
+class Day01(@Lines val items: IntArray) {
     fun part1(): Int? {
         items.forEach { a ->
             items.forEach { b ->
@@ -31,7 +27,3 @@ class Day01(@Lines input: Input<IntArray>) {
 
 }
 
-fun main() = with(createDay<Day01>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day02.kt

@@ -1,17 +1,15 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
-
-data class PasswordEntry(val range: IntRange, val letter: Char, val password: String)
 
 @Day(2)
-class Day02(@Lines input: Input<List<String>>) {
+class Day02(@Lines input: List<String>) {
+    private data class PasswordEntry(val range: IntRange, val letter: Char, val password: String)
+
     private val regex = "^(\\d+)-(\\d+) ([a-z]): (.*)$".toRegex()
 
-    private val passwords = input.value.map {
+    private val passwords = input.map {
         val (_, min, max, letter, password) = regex.find(it)!!.groupValues
         PasswordEntry(min.toInt()..max.toInt(), letter[0], password)
     }
@@ -22,8 +20,3 @@ class Day02(@Lines input: Input<List<String>>) {
         (pwd[range.first - 1] == letter) xor (pwd[range.last - 1] == letter)
     }
 }
-
-fun main() = with(createDay<Day02>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day03.kt

@@ -1,17 +1,14 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
-
-data class Slope(val x: Int, val y: Int)
 
 @Day(3)
-class Day03(@Lines val input: Input<List<String>>) {
+class Day03(@Lines val input: List<String>) {
+    private data class Slope(val x: Int, val y: Int)
 
-    fun part1(slope: Slope = Slope(x = 3, y = 1)): Int {
-        val grid = input.value
+    private fun findSlope(slope: Slope): Int {
+        val grid = input
         var trees = 0
         var x = 0
         var y = 0
@@ -28,6 +25,8 @@ class Day03(@Lines val input: Input<List<String>>) {
         return trees
     }
 
+    fun part1() = findSlope(Slope(x = 3, y = 1))
+
     fun part2(): Long = listOf(
         Slope(x = 1, y = 1),
         Slope(x = 3, y = 1),
@@ -35,11 +34,6 @@ class Day03(@Lines val input: Input<List<String>>) {
         Slope(x = 7, y = 1),
         Slope(x = 1, y = 2),
     )
-        .map { part1(it).toLong() }
+        .map { findSlope(it).toLong() }
         .reduce { acc, trees -> acc * trees }
 }
-
-fun main() = with(createDay<Day03>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day04.kt

@@ -1,17 +1,15 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Text
-import be.vandewalleh.aoc.utils.input.createDay
 
-typealias Entry = Pair<String, String>
-typealias Entries = List<Entry>
+private typealias Entry = Pair<String, String>
+private typealias Entries = List<Entry>
 
 @Day(4)
-class Day04(@Text val input: Input<String>) {
+class Day04(@Text val input: String) {
 
-    val entries = input.value.split("\n\n").map {
+    val entries = input.split("\n\n").map {
         it.split(" ", "\n").map { it.split(":").let { (k, v) -> k to v } }
     }
 
@@ -42,8 +40,3 @@ class Day04(@Text val input: Input<String>) {
 
     fun part2() = entries.count { it.hasRequiredKeys() && it.all { it.isValid() } }
 }
-
-fun main() = with(createDay<Day04>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day05.kt

@@ -1,14 +1,12 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
 
 @Day(5)
-class Day05(@Lines val input: Input<List<String>>) {
+class Day05(@Lines val input: List<String>) {
 
-    private val ids = input.value.map {
+    private val ids = input.map {
         it.replace("F", "0")
             .replace("B", "1")
             .replace("L", "0")
@@ -22,8 +20,3 @@ class Day05(@Lines val input: Input<List<String>>) {
         .find { (a, b) -> b - a > 1 }!!
         .first() + 1
 }
-
-fun main() = with(createDay<Day05>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day06.kt

@@ -1,15 +1,13 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Text
-import be.vandewalleh.aoc.utils.input.createDay
 import org.eclipse.collections.impl.factory.primitive.CharBags
 
 @Day(6)
-class Day06(@Text val input: Input<String>) {
+class Day06(@Text val input: String) {
 
-    private val groups = input.value.split("\n\n")
+    private val groups = input.split("\n\n")
 
     fun part1() = groups.sumBy { it.replace("\n", "").toCharArray().toSet().size }
 
@@ -23,8 +21,3 @@ class Day06(@Text val input: Input<String>) {
     }
 
 }
-
-fun main() = with(createDay<Day06>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day07.kt

@@ -1,18 +1,16 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
 import org.eclipse.collections.api.factory.Stacks
 import org.eclipse.collections.api.multimap.list.ImmutableListMultimap
 import org.eclipse.collections.api.stack.MutableStack
 import org.eclipse.collections.impl.factory.Multimaps
 
-data class Bag(val count: Int, val color: String)
-
 @Day(7)
-class Day07(@Lines val input: Input<List<String>>) {
+class Day07(@Lines val input: List<String>) {
+
+    private data class Bag(val count: Int, val color: String)
 
     private val map: ImmutableListMultimap<String, Bag>
 
@@ -22,7 +20,7 @@ class Day07(@Lines val input: Input<List<String>>) {
         val colorRegex = "^(\\w+ \\w+)".toRegex()
         val requirementRegex = "(\\d+) (\\w+ \\w+) bag".toRegex()
 
-        for (line in input.value) {
+        for (line in input) {
             val outerColor = colorRegex.find(line)!!.groupValues[1]
             for (match in requirementRegex.findAll(line)) {
                 val (_, count, color) = match.groupValues
@@ -50,8 +48,3 @@ class Day07(@Lines val input: Input<List<String>>) {
     fun part2() = bagSequence("shiny gold").sumBy { it.count }
 
 }
-
-fun main() = with(createDay<Day07>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day08.kt

@@ -1,21 +1,24 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
 import org.eclipse.collections.impl.factory.primitive.IntLists
 import org.eclipse.collections.impl.factory.primitive.IntSets
 
 @Day(8)
-class Day08(@Lines val input: Input<List<String>>) {
+class Day08(@Lines val input: List<String>) {
 
-    private val instructions = input.value.map {
+    private val instructions = input.map {
         val words = it.split(" ")
         Instruction(Operation.valueOf(words[0].capitalize()), words[1].toInt())
     }.toTypedArray()
 
-    fun part1() = run(instructions)
+    fun part1() = run(instructions).let {
+        when (it) {
+            is VmResult.Looped -> it.acc
+            is VmResult.Terminated -> it.acc
+        }
+    }
 
     private fun run(instructions: Array<Instruction>): VmResult {
         var acc = 0
@@ -41,7 +44,7 @@ class Day08(@Lines val input: Input<List<String>>) {
         return VmResult.Looped(acc)
     }
 
-    fun part2(): VmResult {
+    fun part2(): Int {
         val possibleMutations = IntLists.mutable.empty()
         instructions.forEachIndexed { i, e ->
             if (e.operation == Operation.Jmp || e.operation == Operation.Nop) possibleMutations.add(i)
@@ -54,7 +57,7 @@ class Day08(@Lines val input: Input<List<String>>) {
             }
 
             val res = run(copy)
-            if (res is VmResult.Terminated) return res
+            if (res is VmResult.Terminated) return res.acc
         }
 
         error("No result found")
@@ -62,17 +65,11 @@ class Day08(@Lines val input: Input<List<String>>) {
 
 }
 
-enum class Operation { Acc, Jmp, Nop }
+private enum class Operation { Acc, Jmp, Nop }
 
-data class Instruction(val operation: Operation, val argument: Int)
+private data class Instruction(val operation: Operation, val argument: Int)
 
-sealed class VmResult {
+private sealed class VmResult {
     data class Looped(val acc: Int) : VmResult()
     data class Terminated(val acc: Int) : VmResult()
 }
-
-fun main() {
-    val day = createDay<Day08>()
-    println(day.part1())
-    println(day.part2())
-}

2020/src/main/kotlin/Day09.kt

@@ -1,20 +1,16 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
 
 @Day(9)
-class Day09(@Lines val input: Input<LongArray>) {
+class Day09(@Lines val input: LongArray) {
 
     private var part1Result = 0L
 
     fun part1(): Long? {
-        val longs = input.value
-
-        for (windowStart in 0 until longs.size - 26) {
-            val last = longs[windowStart + 25]
+        for (windowStart in 0 until input.size - 26) {
+            val last = input[windowStart + 25]
             if (!isValid(windowStart, last)) {
                 part1Result = last
                 return last
@@ -27,8 +23,8 @@ class Day09(@Lines val input: Input<LongArray>) {
     private fun isValid(windowStart: Int, last: Long): Boolean {
         for (i in windowStart until windowStart + 25) {
             for (j in windowStart + 1 until windowStart + 25) {
-                val f = input.value[i]
-                val s = input.value[j]
+                val f = input[i]
+                val s = input[j]
                 if (f + s == last && f != s) return true
             }
         }
@@ -38,10 +34,10 @@ class Day09(@Lines val input: Input<LongArray>) {
     fun part2(): Long {
         var size = 2
         while (true) {
-            for (startIndex in input.value.indices) {
-                val lastIndex = input.value.size - 1 - size
+            for (startIndex in input.indices) {
+                val lastIndex = input.size - 1 - size
                 if (startIndex + size > lastIndex) break
-                val slice = input.value.sliceArray(startIndex..startIndex + size)
+                val slice = input.sliceArray(startIndex..startIndex + size)
                 if (slice.sum() == part1Result) return slice.minOrNull()!! + slice.maxOrNull()!!
             }
             size++
@@ -49,8 +45,3 @@ class Day09(@Lines val input: Input<LongArray>) {
     }
 
 }
-
-fun main() = with(createDay<Day09>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day10.kt

@@ -1,18 +1,16 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
 import org.eclipse.collections.api.list.primitive.MutableIntList
 import org.eclipse.collections.impl.factory.primitive.IntLists
 import org.eclipse.collections.impl.factory.primitive.IntLongMaps
 
 @Day(10)
-class Day10(@Lines val input: Input<IntArray>) {
+class Day10(@Lines val input: IntArray) {
 
     fun part1(): Int {
-        val sorted = IntLists.mutable.of(0, *input.value).apply {
+        val sorted = IntLists.mutable.of(0, *input).apply {
             sortThis()
             add(last + 3)
         }.toArray().toList()
@@ -29,7 +27,7 @@ class Day10(@Lines val input: Input<IntArray>) {
     }
 
     fun part2(): Long {
-        val sorted: MutableIntList = IntLists.mutable.of(*input.value).apply { sortThis() }
+        val sorted: MutableIntList = IntLists.mutable.of(*input).apply { sortThis() }
 
         val map = IntLongMaps.mutable.empty().apply {
             put(0, 1L)
@@ -43,8 +41,3 @@ class Day10(@Lines val input: Input<IntArray>) {
     }
 
 }
-
-fun main() = with(createDay<Day10>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day11.kt

@@ -1,34 +1,32 @@
 package be.vandewalleh.aoc.days
 
 import be.vandewalleh.aoc.utils.input.Day
-import be.vandewalleh.aoc.utils.input.Input
 import be.vandewalleh.aoc.utils.input.Lines
-import be.vandewalleh.aoc.utils.input.createDay
 
-typealias Seats = Array<CharArray>
+private typealias Seats = Array<CharArray>
 
-fun Seats.deepClone(): Seats = map { it.clone() }.toTypedArray()
+private fun Seats.deepClone(): Seats = map { it.clone() }.toTypedArray()
 
-operator fun Seats.get(x: Int, y: Int): Char = this[y][x]
-operator fun Seats.set(x: Int, y: Int, value: Char) {
+private operator fun Seats.get(x: Int, y: Int): Char = this[y][x]
+private operator fun Seats.set(x: Int, y: Int, value: Char) {
     this[y][x] = value
 }
 
-operator fun Seats.contains(xy: Pair<Int, Int>): Boolean {
+private operator fun Seats.contains(xy: Pair<Int, Int>): Boolean {
     val (x, y) = xy
     return x in 0 until width && y in 0 until height
 }
 
-val Seats.width get() = first().size
-val Seats.height get() = size
+private val Seats.width get() = first().size
+private val Seats.height get() = size
 
-fun Seats.asGridString() = joinToString("\n") { it.joinToString("") }
-fun Seats.countOccupied() = sumBy { it.count { it == '#' } }
+private fun Seats.asGridString() = joinToString("\n") { it.joinToString("") }
+private fun Seats.countOccupied() = sumBy { it.count { it == '#' } }
 
 @Day(11)
-class Day11(@Lines val input: Input<List<String>>) {
+class Day11(@Lines val input: List<String>) {
 
-    private val seats: Seats = input.value.map { it.toCharArray() }.toTypedArray()
+    private val seats: Seats = input.map { it.toCharArray() }.toTypedArray()
 
     private val directions = listOf(
         -1 to -1,
@@ -116,8 +114,3 @@ class Day11(@Lines val input: Input<List<String>>) {
     fun part2() = findLastRepeating(seats, ::progress2).countOccupied()
 
 }
-
-fun main() = with(createDay<Day11>()) {
-    println(part1())
-    println(part2())
-}

2020/src/main/kotlin/Day12.kt

@@ -0,0 +1,79 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+import kotlin.math.abs
+
+@Day(12)
+class Day12(@Lines val input: List<String>) {
+
+    fun part1(): Int {
+        var x = 0
+        var y = 0
+        var facing = "E"
+
+        val dirs = listOf("N", "E", "S", "W")
+
+        input.forEach {
+            val dir = it.take(1)
+            val steps = it.drop(1).toInt()
+
+            when (dir) {
+                "L" -> repeat(steps / 90) {
+                    val i = (dirs.indexOf(facing) + 4 - 1) % 4
+                    facing = dirs[i]
+                }
+                "R" -> repeat(steps / 90) {
+                    val i = (dirs.indexOf(facing) + 1) % 4
+                    facing = dirs[i]
+                }
+            }
+
+            when (if (dir == "F") facing else dir) {
+                "N" -> y -= steps
+                "S" -> y += steps
+                "W" -> x -= steps
+                "E" -> x += steps
+            }
+
+        }
+
+        return abs(x) + abs(y)
+    }
+
+    fun part2(): Int {
+        var x = 0
+        var y = 0
+
+        var waypointX = 10
+        var waypointY = -1
+
+        input.forEach {
+            val dir = it.take(1)
+            val steps = it.drop(1).toInt()
+
+            when (dir) {
+                "L" -> repeat(steps / 90) {
+                    val oldY = waypointY
+                    waypointY = -waypointX
+                    waypointX = oldY
+                }
+                "R" -> repeat(steps / 90) {
+                    val oldY = waypointY
+                    waypointY = waypointX
+                    waypointX = -oldY
+                }
+                "F" -> {
+                    x += waypointX * steps
+                    y += waypointY * steps
+                }
+                "N" -> waypointY -= steps
+                "S" -> waypointY += steps
+                "W" -> waypointX -= steps
+                "E" -> waypointX += steps
+            }
+        }
+
+        return abs(x) + abs(y)
+    }
+}

2020/src/main/kotlin/Day13.kt

@@ -0,0 +1,48 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+import kotlin.math.abs
+
+private data class Bus(val index: Int, val id: Long)
+
+@Day(13)
+class Day13(@Lines val input: List<String>) {
+
+    fun part1(): Int {
+        val id = input[0].toInt()
+
+        val (busId, min) = input[1]
+            .splitToSequence(",")
+            .filterNot { it == "x" }
+            .map { it.toInt() }
+            .map { bus -> bus to id / bus }
+            .map { (bus, div) -> bus to bus * (div + 1) }
+            .minByOrNull { it.second }!!
+
+        return busId * abs(min - id)
+    }
+
+    private tailrec fun gcd(a: Long, b: Long): Long = if (b == 0L) a else gcd(b, a % b)
+    private fun lcm(a: Long, b: Long): Long = a / gcd(a, b) * b
+
+    fun part2(): Long {
+        val buses = input[1]
+            .splitToSequence(",")
+            .mapIndexedNotNull { index, bus ->
+                if (bus == "x") null
+                else Bus(index, bus.toLong())
+            }
+            .toList()
+
+        var step = 1L
+        var t = 0L
+
+        for ((i, id) in buses) {
+            while ((t + i) % id != 0L) t += step
+            step = lcm(step, id)
+        }
+
+        return t
+    }
+}

2020/src/main/kotlin/Day14.kt

@@ -0,0 +1,93 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+import kotlin.math.pow
+import org.eclipse.collections.impl.factory.primitive.IntObjectMaps
+import org.eclipse.collections.impl.factory.primitive.LongIntMaps
+
+@Day(14)
+class Day14(@Lines val input: List<String>) {
+
+    private val memRe = "mem\\[(\\d+)] = (.*)$".toRegex()
+
+    private fun Long.toBin36() = toString(2).padStart(length = 36, padChar = '0')
+
+    fun part1(): Long {
+        val mem = IntObjectMaps.mutable.empty<String>()
+
+        var currentMask: String = ""
+
+        for (line in input) {
+            if (line.startsWith("mask")) {
+                currentMask = line.removePrefix("mask = ")
+            } else {
+                val (address, value) = memRe.find(line)!!.destructured
+                val bin = value.toLong().toBin36()
+
+                val result = bin.zip(currentMask)
+                    .map { (bin, mask) -> if (mask != 'X') mask else bin }
+                    .joinToString("")
+
+                mem.put(address.toInt(), result)
+            }
+        }
+
+        return mem.values()
+            .map { it.dropWhile { it == '0' } }
+            .map { it.toLong(2) }
+            .sum()
+    }
+
+    fun part2(): Long {
+        val mem = LongIntMaps.mutable.empty()
+
+        var currentMask = ""
+
+        for (line in input) {
+            if (line[1] == 'a') {
+                currentMask = line.substring(7)
+            } else {
+
+                val (address, value) = memRe.find(line)!!.destructured.let { (add, value) ->
+                    add.toLong().toBin36() to value.toInt()
+                }
+
+                val mutations = generateMutations(currentMask, address)
+
+                for (mutation in mutations) {
+                    mem.put(String(mutation).toLong(2), value)
+                }
+            }
+        }
+
+        return mem.values().sum()
+    }
+
+    private fun generateMutations(mask: String, address: String): Array<CharArray> {
+        val mutationCount = mask.count { it == 'X' }.let { 2.0.pow(it.toDouble()).toInt() }
+        val mutations = Array(mutationCount) { CharArray(36) }
+
+        var groups = 1
+
+        for (i in mask.indices) {
+            when (mask[i]) {
+                'X' -> {
+                    groups *= 2
+                    val groupSize = mutationCount / groups
+                    var currentChar = '1'
+                    for (b in mutations.indices) {
+                        val builder = mutations[b]
+                        val flip = b % groupSize == 0
+                        if (flip) currentChar = if (currentChar == '0') '1' else '0'
+                        builder[i] = currentChar
+                    }
+                }
+                '1' -> mutations.forEach { it[i] = '1' }
+                else -> mutations.forEach { it[i] = address[i] }
+            }
+        }
+        return mutations
+    }
+
+}

2020/src/main/kotlin/Day15.kt

@@ -0,0 +1,43 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Csv
+import be.vandewalleh.aoc.utils.input.Day
+import kotlin.math.abs
+import org.eclipse.collections.impl.factory.primitive.IntObjectMaps
+
+@Day(15)
+class Day15(@Csv val input: IntArray) {
+
+    private fun run(until: Int): Int {
+        val start = input
+
+        val map = IntObjectMaps.mutable.empty<IntArray>()
+
+        var last = -1
+
+        fun say(round: Int, number: Int) {
+            val lastValues = map.get(number)
+            val values = lastValues
+                ?.let { intArrayOf(round, it.maxOrNull()!!) }
+                ?: intArrayOf(round)
+
+            map.put(number, values)
+            last = number
+        }
+
+        for (i in 1..until) {
+            if (i <= start.size) {
+                say(i, start[i - 1])
+            } else {
+                val lastValues = map.get(last)
+                if (lastValues?.size ?: 0 < 2) say(i, 0)
+                else say(i, abs(lastValues[0] - lastValues[1]))
+            }
+        }
+        return last
+    }
+
+    fun part1() = run(until = 2020)
+
+    fun part2() = run(until = 30000000)
+}

2020/src/main/kotlin/Day16.kt

@@ -0,0 +1,148 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Groups
+import org.eclipse.collections.api.multimap.list.ListMultimap
+import org.eclipse.collections.api.multimap.list.MutableListMultimap
+import org.eclipse.collections.api.multimap.set.MutableSetMultimap
+import org.eclipse.collections.impl.factory.Multimaps
+import org.eclipse.collections.impl.multimap.list.FastListMultimap
+
+@Day(16)
+class Day16(@Groups val input: List<List<String>>) {
+
+    private val rangesGroup = input[0]
+    private val myTicket = input[1][1]
+    private val nearbyTicketsGroup = input[2].drop(1)
+
+    private val rangeRe = "(\\d+)-(\\d+)".toRegex()
+
+    private fun extractRanges(line: String): Sequence<IntRange> = rangeRe.findAll(line)
+        .map {
+            val (min, max) = it.destructured
+            min.toInt()..max.toInt()
+        }
+
+    fun part1(): Int {
+        val minMax = mutableListOf<IntRange>()
+
+        for (line in rangesGroup) {
+            minMax.addAll(extractRanges(line))
+        }
+
+        val nearbyTickets = mutableListOf<Int>()
+        for (line in nearbyTicketsGroup) {
+            line.splitToSequence(",").forEach { nearbyTickets.add(it.toInt()) }
+        }
+
+        val invalid = mutableListOf<Int>()
+        nearbyTickets.forEach { number ->
+            if (minMax.none { number in it }) invalid.add(number)
+        }
+
+        return invalid.sum()
+    }
+
+    private fun isTicketValid(ticket: List<Int>, ranges: Iterable<IntRange>): Boolean {
+        for (number in ticket) {
+            if (!ranges.any { number in it }) return false
+        }
+        return true
+    }
+
+    private fun inRanges(value: Int, ranges: List<IntRange>) = ranges.any { value in it }
+
+    fun part2(): Long {
+        val rangesByName = namedRanges()
+        val validTickets = validTickets(rangesByName)
+        val indexesByCategory = indexesByCategory(rangesByName, validTickets)
+
+        removeDuplicates(indexesByCategory)
+
+        val myTicketValues = myTicket.split(",").map { it.toInt() }
+
+        var mult = 1L
+        indexesByCategory.forEachKeyValue { category, index ->
+            if (category.startsWith("departure")) {
+                mult *= myTicketValues[index]
+            }
+        }
+        return mult
+    }
+
+    private fun removeDuplicates(indexesByCategory: MutableSetMultimap<String, Int>) {
+        val toBeRemoved = HashSet<Int>()
+        val queue = ArrayDeque<Int>()
+
+        indexesByCategory.multiValuesView()
+            .toSortedListBy { it.size() }
+            .forEach { it.forEach { if (toBeRemoved.add(it)) queue.add(it) } }
+
+        queue.removeLast()
+
+        val categoriesToRemove = mutableListOf<String>()
+
+        while (queue.isNotEmpty()) {
+            val duplicate = queue.removeFirst()
+
+            categoriesToRemove.clear()
+
+            for (entry in indexesByCategory.keyMultiValuePairsView()) {
+                if (entry.two.size() < 2) continue
+                categoriesToRemove.add(entry.one)
+            }
+
+            for (category in categoriesToRemove) {
+                indexesByCategory.remove(category, duplicate)
+            }
+        }
+    }
+
+    private fun indexesByCategory(
+        rangesByName: ListMultimap<String, IntRange>,
+        validTickets: List<List<Int>>,
+    ): MutableSetMultimap<String, Int> {
+        val indexesByCategory = Multimaps.mutable.set.empty<String, Int>()
+
+        for (entry in rangesByName.keyMultiValuePairsView()) {
+            val category = entry.one
+            val ranges = entry.two.toList()
+
+            for (i in validTickets.first().indices) {
+                var allInRange = true
+                for(ticket in validTickets){
+                    val current = ticket[i]
+                    if(!inRanges(current, ranges)){
+                        allInRange = false
+                        break
+                    }
+                }
+                if (allInRange) indexesByCategory.put(category, i)
+            }
+        }
+        return indexesByCategory
+    }
+
+    private fun validTickets(rangesByName: MutableListMultimap<String, IntRange>): List<List<Int>> {
+        val validTickets = mutableListOf<List<Int>>()
+        val ranges = rangesByName.valuesView().toList()
+        for (line in nearbyTicketsGroup) {
+            val ticket = line.split(",").map { it.toInt() }
+            if (isTicketValid(ticket, ranges)) {
+                validTickets.add(ticket)
+            }
+        }
+        return validTickets
+    }
+
+    private fun namedRanges(): MutableListMultimap<String, IntRange> {
+        val rangesByName = FastListMultimap<String, IntRange>()
+        for (line in rangesGroup) {
+            val name = line.substringBefore(":")
+            extractRanges(line).forEach {
+                rangesByName.put(name, it)
+            }
+        }
+        return rangesByName
+    }
+}

2020/src/main/kotlin/Day17.kt

@@ -0,0 +1,87 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+
+private data class Point(val x: Int, val y: Int, val z: Int)
+private data class Point4(val x: Int, val y: Int, val z: Int, val blah: Int)
+
+private enum class State { Active, Inactive }
+
+@Day(17)
+class Day17(@Lines val input: List<String>) {
+
+    fun part1(): Int {
+        val grid = parseGrid { x, y -> Point(x, y, 0) }
+        repeat(6) { step(grid, ::neighbours3) }
+        return grid.values.count { it == State.Active }
+    }
+
+    fun part2(): Int {
+        val grid = parseGrid { x, y -> Point4(x, y, 0, 0) }
+        repeat(6) { step(grid, ::neighbours4) }
+        return grid.values.count { it == State.Active }
+    }
+
+    private fun <T> parseGrid(pointFactory: (x: Int, y: Int) -> T): MutableMap<T, State> {
+        val grid = mutableMapOf<T, State>()
+        input.forEachIndexed { index, row ->
+            row.forEachIndexed { col, char ->
+                val state = if (char == '#') State.Active else State.Inactive
+                grid[pointFactory(index, col)] = state
+            }
+        }
+        return grid
+    }
+
+    private fun <T> step(grid: MutableMap<T, State>, neighbours: (T) -> List<T>) {
+        val modifications = mutableMapOf<T, State>()
+        val pointsToConsider = grid.keys.flatMap { neighbours(it) }.toSet()
+        for (point in pointsToConsider) {
+            val neighbours = neighbours(point)
+            val activeNeighboursCount = neighbours.count { grid[it] ?: State.Inactive == State.Active }
+            val state = grid[point] ?: State.Inactive
+            if (state == State.Active && activeNeighboursCount !in 2..3) {
+                modifications[point] = State.Inactive
+            } else if (activeNeighboursCount == 3) {
+                modifications[point] = State.Active
+            }
+        }
+        for ((point, state) in modifications) {
+            grid[point] = state
+        }
+    }
+
+    private fun neighbours3(point: Point): List<Point> {
+        val points = mutableListOf<Point>()
+        for (x in point.x - 1..point.x + 1) {
+            for (y in point.y - 1..point.y + 1) {
+                for (z in point.z - 1..point.z + 1) {
+                    val generatedPoint = Point(x, y, z)
+                    if (generatedPoint != point)
+                        points.add(generatedPoint)
+                }
+            }
+        }
+        check(points.size == 26) { "Points size was ${points.size}" }
+        return points
+    }
+
+    private fun neighbours4(point: Point4): List<Point4> {
+        val points = mutableListOf<Point4>()
+        for (x in point.x - 1..point.x + 1) {
+            for (y in point.y - 1..point.y + 1) {
+                for (z in point.z - 1..point.z + 1) {
+                    for (blah in point.blah - 1..point.blah + 1) {
+                        val generatedPoint = Point4(x, y, z, blah)
+                        if (generatedPoint != point)
+                            points.add(generatedPoint)
+                    }
+                }
+            }
+        }
+        check(points.size == 80) { "Points size was ${points.size}" }
+        return points
+    }
+
+}

2020/src/main/kotlin/Day18.kt

@@ -0,0 +1,170 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+import java.util.*
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+
+private enum class Operator { Add, Multiply }
+
+private operator fun Operator.invoke(a: Long, b: Long) = when (this) {
+    Operator.Add -> a + b
+    Operator.Multiply -> a * b
+}
+
+private inline fun Logger.debug(msg: () -> Any) {
+    if (isDebugEnabled) debug(msg().toString())
+}
+
+@Day(18)
+class Day18(@Lines val input: List<String>) {
+
+    private val logger = LoggerFactory.getLogger("Day18")
+    private val lines = input.map { it.replace(" ", "") }
+
+    private fun parseGroups(line: String): Map<Int, List<IntRange>> {
+        var depth = 0
+        val groups = mutableMapOf<Int, MutableList<IntRange>>()
+        val openingPars = Stack<Int>()
+
+        for ((index, char) in line.withIndex()) {
+            when (char) {
+                '(' -> {
+                    openingPars.push(index)
+                    depth++
+                }
+                ')' -> {
+                    depth--
+                    val group = groups.getOrPut(depth) { mutableListOf() }
+                    group.add(openingPars.pop()..index)
+                }
+            }
+        }
+
+        return groups.also { logger.debug { it } }
+    }
+
+    private fun solveGroup(group: String, precedence: Boolean) = solveGroup(parseGroup(group), precedence)
+
+    private fun solveGroup(group: Pair<LinkedList<Long>, LinkedList<Operator>>, precedence: Boolean): Long {
+        val (operands, operators) = group
+        logger.debug { operands }
+        logger.debug { operators }
+
+        if (!precedence) {
+            for (i in operators.indices) {
+                val a = operands[i]
+                val b = operands[i + 1]
+
+                val result = operators[i](a, b)
+
+                operands[i + 1] = result
+            }
+
+            return operands.peekLast()
+        } else {
+
+            var i = 0
+            while (operators.any { it == Operator.Add }) {
+
+                val operator = operators[i]
+
+                if (operator == Operator.Add) {
+                    val a = operands[i]
+                    val b = operands[i + 1]
+                    val res = operator(a, b)
+                    operands.removeAt(i)
+                    operands[i] = res
+                    operators.removeAt(i)
+                } else {
+                    i++
+                }
+            }
+
+            return operands.reduce { a, b -> Operator.Multiply(a, b) }
+        }
+    }
+
+    private fun parseGroup(group: String): Pair<LinkedList<Long>, LinkedList<Operator>> {
+        val operands = LinkedList<Long>()
+        val operators = LinkedList<Operator>()
+        val operand = StringBuilder()
+
+        for (char in group) {
+            if (char.isDigit()) {
+                operand.append(char)
+            } else {
+                val operator = when (char) {
+                    '+' -> Operator.Add
+                    '*' -> Operator.Multiply
+                    else -> error("Unknown operator $char")
+                }
+                operators.add(operator)
+                operands.add(operand.toString().toLong())
+                operand.clear()
+            }
+        }
+
+        operands.add(operand.toString().toLong())
+
+        return Pair(operands, operators)
+    }
+
+    private fun solveLine(line: String, precedence: Boolean = false): Long {
+        var l = line
+
+        while (true) {
+            val groups = parseGroups(l)
+            if (groups.isEmpty()) break
+
+            val highestDepth = groups.keys.maxOrNull()!!
+            val solvableRanges = groups[highestDepth]!!
+
+            val solved = ArrayDeque<Pair<IntRange, Long>>()
+
+            for (range in solvableRanges) {
+                val rangeWithoutPars = range.first + 1 until range.last
+                val answer = solveGroup(l.substring(rangeWithoutPars), precedence)
+                solved.addLast(range to answer)
+            }
+
+            var solution = solved.removeFirst()
+            var inside = false
+
+            val builder = StringBuilder()
+
+            for (i in l.indices) {
+                if (!inside && i in solution.first) {
+                    inside = true
+                    builder.append(solution.second)
+                } else if (inside && i !in solution.first) {
+                    inside = false
+
+                    solution = if (solved.isEmpty()) -1..-1 to -1  // avoid null checks..
+                    else solved.removeFirst()
+
+                    builder.append(l[i])
+                } else if (i !in solution.first) {
+                    builder.append(l[i])
+                }
+            }
+
+            l = builder.toString()
+        }
+
+        return solveGroup(l, precedence)
+    }
+
+    fun part1() = lines
+        .parallelStream()
+        .map { solveLine(it) }
+        .reduce { t, u -> t + u }
+        .get()
+
+    fun part2() = lines
+        .parallelStream()
+        .map { solveLine(it, precedence = true) }
+        .reduce { t, u -> t + u }
+        .get()
+}

2020/src/main/kotlin/Day19.kt

@@ -0,0 +1,55 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Groups
+import java.util.*
+
+@Day(19)
+class Day19(@Groups val input: List<List<String>>) {
+    private val rules = input[0]
+    private val messages = input[1]
+
+    sealed class Rule {
+        data class CharRule(val value: Char) : Rule()
+        data class OrRule(val a: List<Int>, val b: List<Int>?) : Rule() {
+            val all get() = listOfNotNull(a, b)
+        }
+    }
+
+    private fun parseRules(): Map<Int, Rule> {
+        val parsedRules = mutableMapOf<Int, Rule>()
+        rules.forEach {
+            val parts = it.split(":", limit = 2)
+            val index = parts[0].toInt()
+            val rule = if ("\"" !in parts[1]) {
+                val p = parts[1].split('|', limit = 2).map { it.trim().split(" ").mapTo(ArrayList(2)) { it.toInt() } }
+                Rule.OrRule(p[0], if (p.size == 2) p[1] else null)
+            } else {
+                Rule.CharRule(parts[1].trim().replace("\"", "")[0])
+            }
+            parsedRules[index] = rule
+        }
+        return parsedRules
+    }
+
+    private fun matches(input: String, queue: ArrayDeque<Int>, rules: Map<Int, Rule>): Boolean =
+        if (queue.isEmpty()) input.isEmpty()
+        else if (input.isEmpty()) queue.isEmpty()
+        else when (val rule = rules[queue.pop()]!!) {
+            is Rule.CharRule -> input[0] == rule.value && matches(input.drop(1), queue, rules)
+            is Rule.OrRule -> rule.all.any { matches(input, queue.clone().apply { it.asReversed().forEach { addFirst(it) } }, rules) }
+        }
+
+    fun part1(): Int {
+        val rules = parseRules()
+        return messages.count { matches(it, ArrayDeque<Int>().apply { add(0) }, rules) }
+    }
+
+    fun part2(): Int {
+        val rules = parseRules().toMutableMap()
+        rules[8] = Rule.OrRule(listOf(42), listOf(42, 8))
+        rules[11] = Rule.OrRule(listOf(42, 31), listOf(42, 11, 31))
+        return messages.count { matches(it, ArrayDeque<Int>().apply { add(0) }, rules) }
+    }
+
+}

2020/src/main/kotlin/Day20.kt

@@ -0,0 +1,202 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.days.geometry.Grid
+import be.vandewalleh.aoc.days.geometry.gridOf
+import be.vandewalleh.aoc.days.geometry.transformations
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Groups
+import kotlin.math.sqrt
+
+private typealias Tile = Grid<Char>
+
+@Day(20)
+class Day20(@Groups val input: List<List<String>>) {
+    private val tiles: Map<Int, Tile> = input
+        .map { it[0].let { it.substring(5 until it.indexOf(':')).toInt() } to it.drop(1) }
+        .associate { (id, tile) -> id to gridOf(tile) }
+
+    private fun Tile.allEdges() = listOf(edges(), edges().map { it.reversed() }).flatten()
+
+    private fun edgesMatch(a: Tile, b: Tile): Boolean {
+        val edges = b.allEdges()
+        return a.allEdges().any { a -> edges.any { a == it } }
+    }
+
+    private fun combine(tiles: List<Tile>) = sequence {
+        for (i in 0 until tiles.lastIndex) {
+            val a = tiles[i]
+            for (j in i + 1 until tiles.size) {
+                val b = tiles[j]
+                yield(a to b)
+            }
+        }
+    }
+
+    private fun tilesByNeighbourCount(): MutableMap<Int, MutableList<Tile>> {
+        val neighbours = combine(tiles.values.toList())
+            .filter { (a, b) -> edgesMatch(a, b) }
+            .map { it.toList() }
+            .flatten()
+            .groupBy { it }
+            .values
+
+        val map = mutableMapOf<Int, MutableList<Tile>>()
+        for (neighbour in neighbours) {
+            map.computeIfAbsent(neighbour.size) { mutableListOf() }.add(neighbour.first())
+        }
+        return map
+    }
+
+    fun part1() = tilesByNeighbourCount()[2]!!
+        .map { tile -> tiles.entries.find { it.value == tile }!!.key.toLong() }
+        .reduce { acc, id -> acc * id }
+
+    private fun neighboursCount(grid: Grid<*>, x: Int, y: Int): Int {
+        var neighboursCount = 2
+        if (x != 0 && x != grid.lastColumnIndex) neighboursCount++
+        if (y != 0 && y != grid.lastRowIndex) neighboursCount++
+        return neighboursCount
+    }
+
+    private fun isLeftOk(grid: Grid<Tile?>, x: Int, y: Int, candidate: Tile) = grid[x - 1, y]
+        ?.let { left -> candidate.firstColumn() == left.lastColumn() }
+        ?: true
+
+    private fun isTopOk(grid: Grid<Tile?>, x: Int, y: Int, candidate: Tile) = grid[x, y - 1]
+        ?.let { top -> candidate.firstRow() == top.lastRow() }
+        ?: true
+
+    private fun isBottomOk(grid: Grid<*>, x: Int, y: Int, candidate: Tile, neighbours: Map<Int, List<Tile>>) =
+        if (y == grid.lastRowIndex) true
+        else neighbours[neighboursCount(grid, x, y + 1)]!!
+            .filterNot { it == candidate }
+            .count { it.transformations().any { candidate.lastColumn() == it.firstColumn() } } == 1
+
+    private fun isRightOk(grid: Grid<*>, x: Int, y: Int, candidate: Tile, neighbours: Map<Int, List<Tile>>) =
+        if (x == grid.lastColumnIndex) true
+        else neighbours[neighboursCount(grid, x + 1, y)]!!
+            .filterNot { it == candidate }
+            .count { it.transformations().any { candidate.lastRow() == it.firstRow() } } == 1
+
+    private fun assembleGrid(): Grid<Tile?> {
+        val size = sqrt(tiles.size.toDouble()).toInt()
+        val grid: Grid<Tile?> = Grid(Array(size) { Array(size) { null } })
+
+        val neighbours: MutableMap<Int, MutableList<Tile>> = tilesByNeighbourCount()
+
+        for (y in 0 until grid.height) {
+            for (x in 0 until grid.width) {
+                val neighboursCount = neighboursCount(grid, x, y)
+                val candidates = neighbours[neighboursCount]!!
+
+                val conditions = mutableListOf<(Tile) -> Boolean>()
+                conditions += { isLeftOk(grid, x, y, it) }
+                conditions += { isTopOk(grid, x, y, it) }
+
+                // why is this condition needed ?
+                if (x == 0 && y == 0) {
+                    conditions += { isBottomOk(grid, x, y, it, neighbours) }
+                    conditions += { isRightOk(grid, x, y, it, neighbours) }
+                }
+
+                var found: Tile? = null
+
+                outer@ for (candidate in candidates) {
+                    for (transform in candidate.transformations()) {
+                        if (conditions.all { it(transform) }) {
+                            found = transform
+                            candidates.remove(candidate)
+                            break@outer
+                        }
+                    }
+                }
+
+                check(found != null)
+                grid[x, y] = found
+            }
+        }
+
+        return grid
+    }
+
+    private fun removeGaps(grid: Grid<Tile?>) {
+        for (y in 0 until grid.height) {
+            for (x in 0 until grid.width) {
+                grid[x, y] = removeGaps(grid[x, y]!!)
+            }
+        }
+    }
+
+    private fun removeGaps(tile: Tile): Tile {
+        val oldData: ArrayList<ArrayList<Char>> = tile.data
+        val newData = ArrayList<ArrayList<Char>>(oldData.size - 2)
+        oldData.subList(1, oldData.size - 1).forEach { d ->
+            val l = ArrayList<Char>().apply {
+                addAll(d.subList(1, d.size - 1))
+            }
+            newData.add(l)
+        }
+        return Tile(newData)
+    }
+
+    private fun gridToTile(grid: Grid<Tile?>): Tile {
+        val newData = ArrayList<ArrayList<Char>>()
+        for (y in 0 until grid.height) {
+            val row = grid.row(y)
+            for (yy in 0 until row[0]!!.height) {
+                val combinedRow = ArrayList<Char>().also { newData.add(it) }
+                row.forEach { combinedRow.addAll(it!!.row(yy)) }
+            }
+        }
+        return Tile(newData)
+    }
+
+    private fun Tile.subGridData(startX: Int, startY: Int, width: Int, height: Int): List<List<Char>> {
+        val newData = ArrayList<ArrayList<Char>>()
+        for (y in startY until startY + height) {
+            val row = ArrayList<Char>().also { newData.add(it) }
+            for (x in startX until startX + width) {
+                row.add(this[x, y]!!)
+            }
+        }
+        return newData
+    }
+
+    private fun List<List<Char>>.isMonster(monster: List<List<Char>>): Boolean {
+        val monsterRe = monster.joinToString("") { it.joinToString("") }.replace(" ", ".").toRegex()
+        val str = this.joinToString("") { it.joinToString("") }
+        return monsterRe.matches(str)
+    }
+
+    fun part2(): Int {
+        val grid = assembleGrid()
+        removeGaps(grid)
+        val megaTile = gridToTile(grid)
+
+        val monster: List<List<Char>> = """
+            |                  # |
+            |#    ##    ##    ###|
+            | #  #  #  #  #  #   |
+        """.trimMargin("|").lines().map { it.toCharArray().dropLast(1) }
+
+        val monsterWidth = monster[0].size
+        val monsterHeight = 3
+        val monsterSquares = monster.flatten().count { it == '#' }
+        val squares = megaTile.data.flatten().count { it == '#' }
+
+        for (g in megaTile.transformations()) {
+            var count = 0
+            for (y in 0 until g.lastRowIndex - monsterHeight) {
+                for (x in 0 until g.lastColumnIndex - monsterWidth) {
+                    val subgrid = g.subGridData(x, y, monsterWidth, monsterHeight)
+                    if (subgrid.isMonster(monster)) {
+                        count++
+                    }
+                }
+            }
+            if (count != 0) return squares - (count * monsterSquares)
+        }
+        error("No monsters found")
+    }
+
+}

2020/src/main/kotlin/Day21.kt

@@ -0,0 +1,57 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+import org.eclipse.collections.api.factory.Bags
+import org.eclipse.collections.api.multimap.set.MutableSetMultimap
+import org.eclipse.collections.impl.factory.Multimaps
+
+@Day(21)
+class Day21(@Lines val input: List<String>) {
+    private val foods = input.map { line ->
+        val parOpen = line.indexOf('(')
+        val ingredients = line.substring(0 until parOpen - 1).split(" ")
+        val allergens = line.substring(parOpen + 1 until line.length - 1).removePrefix("contains ").split(", ")
+        ingredients to allergens
+    }
+
+    private val allIngredients = foods.flatMap { it.first }.toSet()
+    private val allAllergens = foods.flatMap { it.second }.toSet()
+    private val dangerousIngredients = dangerousIngredients()
+
+    fun part1(): Int {
+        val occurrences = Bags.mutable.empty<String>()
+        foods.forEach { (ingredients) -> occurrences.addAll(ingredients) }
+        return allIngredients.filter { !dangerousIngredients.containsValue(it) }
+            .map { ingredient -> occurrences.count { it == ingredient } }
+            .sum()
+    }
+
+    fun part2(): String {
+        while (!dangerousIngredients.multiValuesView().all { it.size() == 1 }) {
+            dangerousIngredients.multiValuesView()
+                .filter { it.size() == 1 }
+                .map { it.first() }
+                .forEach { removeMe ->
+                    dangerousIngredients.keyMultiValuePairsView()
+                        .filter { it.two.size() != 1 && it.two.contains(removeMe) }
+                        .forEach { dangerousIngredients.remove(it.one, removeMe) }
+                }
+        }
+        return dangerousIngredients.keySet().sorted().joinToString(",") { dangerousIngredients.get(it).first() }
+    }
+
+    private fun dangerousIngredients(): MutableSetMultimap<String, String> {
+        val map = Multimaps.mutable.set.empty<String, String>()
+        allAllergens.forEach { map.putAll(it, allIngredients) }
+
+        foods.forEach { (ingredients, allergens) ->
+            allergens.forEach { allergen ->
+                allIngredients.forEach {
+                    if (!ingredients.contains(it)) map.remove(allergen, it)
+                }
+            }
+        }
+        return map
+    }
+}

2020/src/main/kotlin/Day22.kt

@@ -0,0 +1,76 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Groups
+
+private data class PlayedGame(val a: List<Int>, val b: List<Int>)
+
+@Day(22)
+class Day22(@Groups val input: List<List<String>>) {
+    private val one = input[0].drop(1).map { it.toInt() }
+    private val two = input[1].drop(1).map { it.toInt() }
+
+    fun part1(): Long {
+        val oneDeque = ArrayDeque(one)
+        val twoDeque = ArrayDeque(two)
+
+        while (oneDeque.isNotEmpty() && twoDeque.isNotEmpty()) {
+            val a = oneDeque.removeFirst()
+            val b = twoDeque.removeFirst()
+
+            if (a > b) {
+                oneDeque.addLast(a)
+                oneDeque.addLast(b)
+            } else {
+                twoDeque.addLast(b)
+                twoDeque.addLast(a)
+            }
+        }
+
+        val deque = if (oneDeque.isEmpty()) twoDeque else oneDeque
+        return deque.score()
+    }
+
+    private fun ArrayDeque<Int>.score() =
+        asReversed().mapIndexed { index, value -> (index + 1).toLong() * value.toLong() }.sum()
+
+    fun part2(): Long {
+        val oneDeque = ArrayDeque(one)
+        val twoDeque = ArrayDeque(two)
+
+        val winner = playGame(oneDeque, twoDeque)
+        val deque = if (winner == 1) oneDeque else twoDeque
+        return deque.score()
+    }
+
+    private fun playGame(one: ArrayDeque<Int>, two: ArrayDeque<Int>): Int {
+        val playedGames = mutableSetOf<PlayedGame>()
+
+        while (one.isNotEmpty() && two.isNotEmpty()) {
+            if (!playedGames.add(PlayedGame(one.toList(), two.toList()))) return 1
+
+            val a = one.removeFirst()
+            val b = two.removeFirst()
+
+            val winner = when {
+                one.size >= a && two.size >= b -> playGame(
+                    ArrayDeque(one.take(a)),
+                    ArrayDeque(two.take(b))
+                )
+                a > b -> 1
+                else -> 2
+            }
+
+            if (winner == 1) {
+                one.addLast(a)
+                one.addLast(b)
+            } else {
+                two.addLast(b)
+                two.addLast(a)
+            }
+
+        }
+
+        return if (one.isEmpty()) 2 else 1
+    }
+}

2020/src/main/kotlin/Day23.kt

@@ -0,0 +1,111 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Text
+
+@Day(23)
+class Day23(@Text val input: String) {
+    private val cups = input.toCharArray().map { it.toString().toInt() }
+
+    private fun <T> ringSequence(head: Ring.Node<T>) = generateSequence(head) { it.next }
+
+    class Ring<T>(items: Iterable<T>) {
+
+        class Node<T>(var value: T) {
+            lateinit var next: Node<T>
+            override fun toString() = "Node($value -> ${next.value})"
+        }
+
+        private var last: Node<T>? = null
+        private var first: Node<T>? = null
+
+        init {
+            items.forEach { item ->
+                val node = Node(item)
+                if (first == null) first = node
+                last?.next = node
+                last = node
+            }
+            check(first != null && last != null)
+            last?.next = first!!
+        }
+
+        fun first() = first!!
+    }
+
+    private fun Ring.Node<Int>.cached(size: Int): Array<Ring.Node<Int>> =
+        arrayOfNulls<Ring.Node<Int>>(size + 1).also { array ->
+            array[0] = Ring.Node(-1)
+            ringSequence(this).take(size).forEach { array[it.value] = it }
+        } as Array<Ring.Node<Int>>
+
+    fun part1(): String {
+        var currentNode = Ring(cups).first()
+        val cache = currentNode.cached(cups.size)
+        val max = cups.maxOrNull()!!
+
+        repeat(100) { currentNode = move(max, cache, currentNode) }
+
+        return ringSequence(currentNode)
+            .dropWhile { it.value != 1 }
+            .drop(1)
+            .take(cups.size - 1)
+            .map { it.value }
+            .joinToString("")
+    }
+
+    fun part2(): Long {
+        fun fillCups(): List<Int> {
+            val cups = ArrayList<Int>(1_000_000)
+            cups.addAll(this.cups)
+            val highest = this.cups.maxOrNull()!!
+
+            for (i in 1..1_000_000 - cups.size) {
+                cups.add(highest + i)
+            }
+
+            return cups
+        }
+
+        val size = 1_000_000
+        var currentNode = Ring(fillCups()).first()
+        val cache = currentNode.cached(size)
+
+        repeat(10_000_000) { currentNode = move(max = size, cache, currentNode) }
+
+        val one = cache[1]
+        val a = one.next
+        val b = a.next
+        return a.value.toLong() * b.value.toLong()
+    }
+
+    private fun move(max: Int, cache: Array<Ring.Node<Int>>, current: Ring.Node<Int>): Ring.Node<Int> {
+        val a = current.next
+        val b = a.next
+        val c = b.next
+
+        current.next = c.next
+
+        val aa = a.value
+        val bb = b.value
+        val cc = c.value
+
+        val destinationNode: Ring.Node<Int>
+        var i = current.value - 1
+        while (true) {
+            if (i < 1) i = max
+            val value = cache[i].value
+            if (value == aa || value == bb || value == cc) {
+                i--
+            } else {
+                destinationNode = cache[i]
+                break
+            }
+        }
+
+        val destinationNextNode = destinationNode.next
+        destinationNode.next = a
+        c.next = destinationNextNode
+        return current.next
+    }
+}

2020/src/main/kotlin/Day24.kt

@@ -0,0 +1,65 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+import org.eclipse.collections.api.bag.Bag
+import org.eclipse.collections.api.bag.MutableBag
+import org.eclipse.collections.api.factory.Bags
+
+@Day(24)
+class Day24(@Lines val input: List<String>) {
+
+    private data class HexPoint(val x: Int, val y: Int, val z: Int) {
+        fun translate(other: HexPoint) = HexPoint(this.x + other.x, this.y + other.y, this.z + other.z)
+    }
+
+    private enum class Direction(vararg coordinates: Int) {
+        E(1, -1, 0),
+        SE(0, -1, 1),
+        SW(-1, 0, 1),
+        W(-1, 1, 0),
+        NW(0, 1, -1),
+        NE(1, 0, -1);
+
+        val coordinates = HexPoint(coordinates[0], coordinates[1], coordinates[2])
+    }
+
+    private fun parseTile(line: String) = "e|se|sw|w|nw|ne".toRegex()
+        .findAll(line)
+        .flatMap { it.groupValues }
+        .map { Direction.valueOf(it.toUpperCase()) }
+        .toList()
+
+    private val tiles = input.map { parseTile(it) }.map {
+        it.map { it.coordinates }.reduce { acc, ints -> acc.translate(ints) }
+    }
+
+    fun part1() = Bags.immutable.ofAll(tiles).selectBlacks().size()
+
+    private fun Bag<HexPoint>.selectBlacks() = selectByOccurrences { it % 2 == 1 }
+
+    private fun HexPoint.adjacents() = Direction.values().map { this.translate(it.coordinates) }
+
+    // black -> odd
+    // white -> even || not in bag -> !in black
+    private fun day(bag: MutableBag<HexPoint>) {
+        val blacks = bag.selectBlacks().toSet()
+
+        val all = (bag + bag.flatMap { it.adjacents() }).toSet()
+
+        for (tile in all) {
+            val adjacents = tile.adjacents()
+            val adjacentBlacks = adjacents.count { it in blacks }
+            val isBlack = tile in blacks
+
+            if (isBlack && (adjacentBlacks == 0 || adjacentBlacks > 2)) bag.setOccurrences(tile, 2)
+            else if (!isBlack && adjacentBlacks == 2) bag.setOccurrences(tile, 1)
+        }
+    }
+
+    fun part2(): Int {
+        val bag = Bags.mutable.ofAll(tiles)
+        repeat(100) { day(bag) }
+        return bag.selectBlacks().size()
+    }
+}

2020/src/main/kotlin/Day25.kt

@@ -0,0 +1,44 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.input.Day
+import be.vandewalleh.aoc.utils.input.Lines
+
+@Day(25)
+class Day25(@Lines val input: IntArray) {
+    private val doorPublicKey = input[0]
+    private val cardPublicKey = input[1]
+
+    private fun encryptionKey(loopSize: Int, publicKey: Int) = transformSubjectNumber(loopSize, publicKey)
+
+    private fun transformSubjectNumber(loopSize: Int, subjectNumber: Int): Int {
+        var number = 1L
+        repeat(loopSize) {
+            number *= subjectNumber
+            number %= 20201227
+        }
+        return number.toInt()
+    }
+
+    private fun transformSubjectNumberStartingWith(currentNumber: Long, subjectNumber: Int): Long {
+        var number = currentNumber
+        number *= subjectNumber
+        number %= 20201227
+        return number
+    }
+
+    private fun findLoopSize(expectedPublicKey: Long): Int {
+        var computedPublicKey = 1L
+        var loopSize = 0
+        do {
+            computedPublicKey = transformSubjectNumberStartingWith(computedPublicKey, 7)
+            loopSize++
+        } while (computedPublicKey != expectedPublicKey)
+        return loopSize
+    }
+
+    fun part1(): Int {
+        val cardLoopSize = findLoopSize(cardPublicKey.toLong())
+        return encryptionKey(cardLoopSize, doorPublicKey)
+    }
+
+}

2020/src/main/kotlin/Main.kt

@@ -0,0 +1,7 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.factory.createDay
+
+fun main() = with(createDay<Day15>()) {
+    println(part1())
+}

2020/src/main/kotlin/geometry/Grid.kt

@@ -0,0 +1,64 @@
+@file:Suppress("MemberVisibilityCanBePrivate")
+
+package be.vandewalleh.aoc.days.geometry
+
+class Grid<T> {
+    val data: ArrayList<ArrayList<T>> = ArrayList()
+
+    constructor(data: Iterable<Iterable<T>>) {
+        data.forEach {
+            this.data.add(ArrayList(it.toList()))
+        }
+    }
+
+    constructor(data: Array<Array<T>>) {
+        data.forEach {
+            this.data.add(ArrayList(it.toList()))
+        }
+    }
+
+    val width get() = data[0].size
+    val lastColumnIndex get() = data[0].size - 1
+
+    val height get() = data.size
+    val lastRowIndex get() = data.size - 1
+
+    operator fun get(x: Int, y: Int): T? {
+        if (y !in 0..lastRowIndex) return null
+        val row = data[y]
+        return if (x !in 0..lastColumnIndex) null
+        else row[x]
+    }
+
+    operator fun set(x: Int, y: Int, value: T) {
+        data[y][x] = value
+    }
+
+    fun row(y: Int): List<T> = data[y]
+    fun firstRow() = row(0)
+    fun lastRow() = row(height - 1)
+
+    fun column(x: Int): List<T> = data.map { it[x] }
+    fun firstColumn() = column(0)
+    fun lastColumn() = column(width - 1)
+
+    fun edges() = listOf(row(0), column(0), row(lastRowIndex), column(lastColumnIndex))
+
+    override fun toString() = buildString {
+        data.forEach { line ->
+            append(line.joinToString(""))
+            appendLine()
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+        other as Grid<*>
+        if (data != other.data) return false
+        return true
+    }
+
+    override fun hashCode() = data.hashCode()
+
+}

2020/src/main/kotlin/geometry/GridFactory.kt

@@ -0,0 +1,7 @@
+package be.vandewalleh.aoc.days.geometry
+
+fun gridOf(lines: List<String>): Grid<Char> =
+    Grid(lines.map { it.toCharArray().toList() })
+
+fun gridOf(lines: String): Grid<Char> =
+    gridOf(lines.lines())

2020/src/main/kotlin/geometry/GridTranformations.kt

@@ -0,0 +1,51 @@
+package be.vandewalleh.aoc.days.geometry
+
+private fun <T> ArrayList<T>.reversed(): ArrayList<T> {
+    val out = ArrayList<T>(this.size)
+    asReversed().forEach { out.add(it) }
+    return out
+}
+
+fun <T> Grid<T>.flipVertically(): Grid<T> = Grid(data.reversed())
+
+fun <T> Grid<T>.flipHorizontally(): Grid<T> {
+    val out = ArrayList<ArrayList<T>>(height)
+    for (y in 0 until height) {
+        out.add(data[y].reversed())
+    }
+    return Grid(out)
+}
+
+fun <T> Grid<T>.rotateRight(): Grid<T> {
+    val out = ArrayList<ArrayList<T>>(width)
+    for (x in 0 until width) {
+        out.add(ArrayList<T>(height))
+        for (y in 0 until height) {
+            out[x].add(data[y][x])
+        }
+    }
+    return Grid(out).flipHorizontally()
+}
+
+fun <T> Grid<T>.rotateLeft(): Grid<T> {
+    val data = flipHorizontally().data
+    val out = ArrayList<ArrayList<T>>(width)
+    for (x in 0 until width) {
+        out.add(ArrayList<T>(height))
+        for (y in 0 until height) {
+            out[x].add(data[y][x])
+        }
+    }
+    return Grid(out).flipHorizontally()
+}
+
+fun <T> Grid<T>.transformations(): Sequence<Grid<T>> = sequence {
+    yield(this@transformations)
+    yield(flipHorizontally())
+    yield(flipVertically())
+    yield(rotateLeft())
+    yield(rotateRight())
+    yield(flipHorizontally().flipVertically())
+    yield(flipVertically().rotateRight())
+    yield(flipVertically().rotateLeft())
+}

2020/src/main/resources/day12.txt

@@ -0,0 +1,770 @@
+F47
+W2
+S5
+R180
+R90
+N3
+F44
+W1
+N3
+F77
+S5
+L270
+F39
+N3
+L90
+F83
+W4
+R270
+E2
+F98
+N3
+R180
+N3
+F54
+N1
+W4
+R90
+N1
+L90
+S2
+E4
+N4
+W2
+R90
+F42
+W3
+S4
+L90
+E5
+F6
+R180
+N4
+E5
+R180
+E3
+N3
+F27
+L90
+S4
+L180
+E4
+F52
+E2
+N1
+R90
+E3
+S4
+F76
+R270
+W2
+R90
+S2
+R90
+F79
+S1
+L180
+F81
+E3
+F79
+L90
+S3
+L180
+F52
+S5
+L90
+N4
+W2
+F65
+N2
+W1
+R90
+F25
+W4
+L90
+S2
+R90
+N1
+F13
+W1
+N1
+F71
+N3
+L90
+W4
+R90
+F91
+W5
+N3
+W3
+S3
+F58
+W4
+N5
+W3
+F42
+S4
+E5
+N3
+F14
+L180
+E5
+L270
+F55
+N3
+R90
+R90
+S4
+F55
+W2
+N1
+W5
+R180
+F8
+E3
+L270
+N2
+F12
+N2
+R90
+W1
+R90
+W2
+L90
+S2
+F75
+L90
+S4
+E3
+F82
+L90
+L90
+F42
+N4
+E5
+F67
+R90
+E3
+F64
+E4
+R90
+F42
+S4
+F85
+W5
+S5
+R90
+F35
+R270
+W5
+F67
+R90
+S5
+R180
+S1
+F13
+N4
+W5
+S2
+F31
+L90
+E2
+F39
+R90
+F3
+W4
+N2
+F14
+E2
+F80
+L180
+F52
+N3
+E2
+F98
+W2
+F29
+R180
+E2
+L90
+W4
+N3
+W1
+S2
+W1
+N5
+F6
+E5
+E1
+W2
+R90
+S3
+F92
+L90
+E5
+F55
+L90
+S3
+R90
+S2
+L90
+N1
+E5
+F50
+L90
+N4
+F9
+L90
+N4
+L90
+R90
+R180
+E3
+F57
+L90
+S5
+R180
+S3
+E4
+F41
+W5
+N4
+W2
+N2
+R90
+S2
+W1
+F83
+R180
+W1
+R90
+W1
+F17
+F20
+S1
+E5
+F13
+N5
+F8
+F81
+E2
+S4
+F7
+W2
+F86
+N2
+L90
+N5
+L180
+E2
+R90
+E3
+S3
+N4
+W2
+F64
+L90
+F81
+L90
+E4
+F1
+E3
+L90
+W5
+L90
+N3
+F28
+F3
+F100
+E5
+N5
+F32
+R90
+W1
+R90
+S3
+W1
+W5
+N3
+F27
+R90
+W2
+R180
+W3
+W2
+N2
+E2
+S1
+R90
+W3
+F51
+E5
+N4
+W3
+S5
+R90
+F91
+S3
+W1
+S4
+R270
+N5
+W4
+F94
+R90
+N4
+L90
+N4
+R90
+F35
+E3
+F6
+S4
+F98
+E2
+L180
+W4
+N5
+F42
+S3
+W3
+N1
+R90
+S5
+E3
+S3
+F47
+S1
+F19
+W5
+R90
+F17
+R90
+N4
+R90
+F57
+E2
+F73
+W3
+F52
+F98
+R90
+N1
+F88
+N2
+E4
+S4
+R90
+E2
+R90
+N5
+F75
+L180
+F61
+E2
+S4
+N4
+W1
+N3
+E2
+N3
+F44
+E3
+L180
+N4
+F16
+E2
+S1
+L180
+R90
+W5
+F65
+S5
+F31
+E3
+L90
+N5
+E4
+S5
+E4
+S4
+R90
+F70
+R90
+W4
+L90
+N3
+W1
+L90
+S3
+L90
+F91
+L180
+S3
+R90
+N5
+L90
+S5
+W2
+F18
+E3
+F19
+N1
+F70
+R90
+E3
+S4
+F46
+N2
+S3
+W2
+S4
+F7
+L90
+E4
+R90
+F78
+S1
+F4
+L90
+W3
+F78
+E5
+L270
+F86
+E3
+F82
+L90
+F32
+R90
+E4
+L90
+E4
+L90
+E3
+F63
+N4
+E4
+L90
+F70
+R180
+F30
+R180
+F40
+N5
+R90
+W4
+F16
+L180
+S1
+W1
+R180
+F12
+W3
+L90
+F93
+S2
+L270
+F36
+L90
+W2
+N2
+F3
+W2
+L180
+L90
+F24
+S1
+W5
+R90
+E4
+L180
+E1
+S1
+L90
+F94
+L90
+F55
+N2
+E5
+F33
+E3
+L90
+N2
+L90
+S2
+R90
+F67
+W4
+F79
+E1
+E5
+F5
+S5
+R180
+F5
+E2
+E5
+N4
+W5
+N4
+W5
+E2
+L90
+F2
+L90
+N4
+E3
+N3
+R90
+F92
+N5
+F83
+L90
+F85
+R90
+W5
+S2
+L90
+E1
+F34
+E3
+L180
+W3
+R90
+F29
+W4
+L90
+F34
+W1
+S4
+E2
+S1
+W2
+W5
+L90
+E5
+N4
+R180
+N2
+W5
+R90
+F42
+W3
+N2
+L90
+F79
+W2
+F16
+N5
+E3
+F52
+F55
+L90
+F42
+L90
+W4
+S2
+E5
+L90
+S4
+F34
+N5
+N1
+L180
+L90
+E2
+L90
+W3
+L90
+F16
+E2
+F96
+N3
+E1
+F34
+R180
+S2
+F17
+W1
+L270
+F7
+W2
+N1
+F33
+N4
+F2
+N5
+R180
+F10
+W3
+L90
+S3
+E2
+S1
+F85
+N2
+F1
+R180
+F10
+N4
+W3
+S2
+R180
+N4
+W3
+S2
+S4
+L90
+E5
+N1
+F34
+S4
+W2
+W5
+F62
+S5
+E5
+S4
+F100
+L90
+W2
+F20
+S2
+E1
+R180
+F88
+N5
+F85
+N2
+R90
+N1
+E5
+F83
+R90
+W1
+R90
+E1
+F11
+E3
+F54
+N5
+L180
+F54
+R90
+S2
+E3
+L90
+E3
+N5
+R90
+W1
+S5
+R270
+F91
+E3
+F52
+W1
+F36
+W1
+N5
+F53
+E1
+R180
+N3
+F12
+L90
+S5
+F99
+S1
+R90
+S4
+R90
+S1
+W1
+N2
+L270
+W5
+F78
+S2
+R90
+F37
+W5
+R90
+E3
+S2
+E4
+L90
+S3
+W4
+F83
+L180
+S3
+R90
+F57
+W1
+S1
+L180
+W2
+N1
+R180
+N1
+L180
+W3
+S3
+R180
+E4
+F77
+N5
+S3
+W1
+N4
+F4
+N5
+F64
+W1
+R90
+N2
+W5
+L90
+N3
+L90
+F8
+L90
+F3
+S5
+F95
+R90
+W2
+F15
+L270
+F49
+R180
+S3
+F15
+N5
+L180
+S2
+F71
+S5
+F56
+W1
+F22
+F90
+E5
+F68
+N4
+R180
+N5
+E4
+F52
+E5
+L90
+E3
+F69
+W4
+S3
+L90
+N4
+R90
+F19

2020/src/main/resources/day13.txt

@@ -0,0 +1,2 @@
+1000511
+29,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,37,x,x,x,x,x,409,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,17,13,19,x,x,x,23,x,x,x,x,x,x,x,353,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,41

2020/src/main/resources/day14.txt

@@ -0,0 +1,559 @@
+mask = 001X11X1X010X1X1010XX10X100101011000
+mem[43398] = 563312
+mem[51673] = 263978
+mem[18028] = 544304215
+mask = X0100001101XX11100010XX110XX11111000
+mem[24151] = 2013
+mem[15368] = 19793
+mem[45005] = 478
+mem[1842] = 190808161
+mem[36033] = 987
+mem[26874] = 102
+mask = 00X0000110110X000110010101XX0X010001
+mem[9507] = 7
+mem[50019] = 16475608
+mem[4334] = 129799
+mem[37373] = 182640
+mem[28170] = 534617265
+mem[6432] = 354252
+mem[36752] = 834628
+mask = 10100000101101100110X001X0X001100X10
+mem[36664] = 30481
+mem[6532] = 103013119
+mem[45659] = 15629
+mem[19533] = 167227
+mem[40461] = 344193233
+mem[6217] = 26713310
+mask = X0XX010100110101X0001101X11100X100X0
+mem[38530] = 6202
+mem[53032] = 13775
+mem[39333] = 1003152
+mem[3932] = 1240562
+mem[59246] = 12638
+mask = 0X1X010100X001X0011000X10000011X11X1
+mem[51007] = 43736089
+mem[32553] = 977
+mem[5131] = 323347526
+mem[21451] = 176282356
+mem[22857] = 118
+mem[50924] = 217
+mask = 001111X110100X11X100000011110111X100
+mem[3954] = 3854
+mem[19628] = 6778501
+mem[29233] = 104
+mem[18456] = 135287
+mem[10018] = 379
+mem[14384] = 969770374
+mask = 0X1X000110X1X10001100110100X01000001
+mem[25112] = 62086
+mem[22964] = 2379583
+mem[45021] = 1429003
+mask = X010XX11X0110110011XX000011000110001
+mem[17265] = 180092
+mem[36033] = 495818745
+mem[28455] = 7765821
+mask = 01000X0110110001100X01X1111000XXX001
+mem[395] = 37390
+mem[6432] = 962
+mem[10247] = 130364
+mem[10136] = 529
+mem[62469] = 62129
+mask = 00001100X010X110011X0000111X0X100XX1
+mem[8811] = 206575
+mem[37066] = 41
+mem[53499] = 1505104
+mem[22863] = 59636084
+mem[50013] = 45392
+mem[29757] = 1343911
+mask = 001000011010X10X10000001XX011X000010
+mem[23068] = 8829046
+mem[49194] = 614470096
+mask = XX1X000110X101100X101100X01101X00X11
+mem[62870] = 3995829
+mem[61328] = 18642
+mem[50232] = 70531300
+mem[48827] = 17923
+mem[12416] = 530017
+mem[33496] = 181946
+mask = 00100X0110XX00011X00000X101100X10100
+mem[64825] = 5590
+mem[55315] = 3210
+mem[532] = 92226
+mask = 00X0XX0000100110011010X0X00XX101011X
+mem[35112] = 1037772
+mem[46051] = 5636
+mem[32440] = 5415168
+mem[6812] = 64661
+mask = XX1111110010110X010XXX0010X0110XX001
+mem[2313] = 14107547
+mem[57582] = 3420940
+mask = 0X100X01101X011101001001111101110X1X
+mem[1584] = 1309601
+mem[45021] = 142440
+mem[52855] = 22177947
+mask = 001X1X11XX101101010010X01X00X100X000
+mem[51649] = 224687001
+mem[30137] = 16118
+mem[49157] = 1286
+mask = 0011010X001X0101110X01000X11011X0100
+mem[8527] = 483
+mem[23222] = 60397
+mem[47303] = 4597311
+mask = 1010001110X00X0010000X100X0X01011100
+mem[61912] = 65321
+mem[28793] = 217
+mem[3216] = 2226
+mem[15267] = 196
+mem[12210] = 634690438
+mask = XX100001100101011XX000001X0X00X10X10
+mem[52112] = 232196
+mem[5131] = 8215922
+mem[21390] = 97675
+mem[60773] = 295919
+mem[10967] = 188393052
+mem[30137] = 40094772
+mask = 01100X00001X0111X11001011X000X1010X0
+mem[47036] = 8270917
+mem[26111] = 3884
+mem[48992] = 3941
+mem[21396] = 9612429
+mask = X01X01X0100X101001XX00001X1101X00110
+mem[47036] = 785762
+mem[20586] = 91901152
+mem[38530] = 338166139
+mem[29577] = 753085
+mask = X01001010001011100X01XX010010011X000
+mem[50548] = 31352881
+mem[17969] = 264
+mem[12532] = 122897915
+mask = 100X0X011011110001001XX0100110010101
+mem[7092] = 488918089
+mem[5131] = 2146748
+mem[13662] = 1422934
+mem[54353] = 299758672
+mem[17622] = 15998
+mem[12416] = 48024869
+mem[15520] = 925305185
+mask = X010000100X1000X1000X10010X010100010
+mem[49608] = 17989
+mem[5478] = 192384
+mem[7958] = 729
+mask = 0010X001X1100X1X1X000100XX10100X1100
+mem[47164] = 170643
+mem[1049] = 151435402
+mem[24631] = 47998921
+mask = 101001XX0X1X010110011101000110110111
+mem[39780] = 29719
+mem[20606] = 714268
+mem[40889] = 367330023
+mem[6414] = 28304231
+mem[63401] = 1417
+mask = 1X10010X00X10101100X010110X1100X1001
+mem[38445] = 392
+mem[14087] = 19086
+mem[36110] = 7609
+mem[61683] = 24000
+mem[55077] = 2975
+mem[2109] = 446867
+mask = 011000011X010X0X1X100110100001X1XX10
+mem[32849] = 150162
+mem[22563] = 3985
+mem[10602] = 225990962
+mask = 00X00X01X00001X1X0000X00101100100110
+mem[43197] = 134523909
+mem[65396] = 266246531
+mem[54292] = 263069
+mem[7677] = 99022189
+mem[16568] = 15208393
+mask = 1X100X011X1000111000XX1100011X00X0X1
+mem[2877] = 1577
+mem[39731] = 1276
+mem[10602] = 844609393
+mem[13447] = 4710
+mask = 0010X00110XX0101100X00XX100110X10100
+mem[10466] = 93198549
+mem[21290] = 624
+mem[2948] = 51676784
+mem[23734] = 6032
+mem[29894] = 48902591
+mem[271] = 60066
+mask = 1011000110X1011X001X11110100110111X0
+mem[1843] = 1562
+mem[1049] = 9936
+mem[14474] = 305948608
+mem[40634] = 680784423
+mem[9394] = 12344199
+mask = 000011X000100X10011X000X001100X10X10
+mem[37198] = 9587
+mem[40486] = 15533376
+mem[28252] = 1625
+mem[59079] = 166206
+mask = 0010010110110XXXXX0X0001100100000X00
+mem[40119] = 168760390
+mem[63012] = 1016
+mem[6964] = 13134
+mem[6116] = 19700991
+mem[60039] = 492285
+mask = 10X000011X10001X100000111X10000101X0
+mem[532] = 16484832
+mem[48228] = 18188385
+mem[65048] = 14886349
+mem[29631] = 1088356
+mask = 0100X00110110X00XXX010110X11X111100X
+mem[24637] = 561045
+mem[62166] = 62287574
+mem[395] = 1350
+mem[46447] = 15165
+mask = 01101XX100110X1X11001X0X0X0X01011110
+mem[29481] = 88712206
+mem[8052] = 965421
+mask = X0X0010100X1X101101X111010X11010X10X
+mem[27388] = 41257883
+mem[22151] = 2499234
+mem[17067] = 1210879
+mask = 00100001X0X10X0110000000101XX001010X
+mem[148] = 43621
+mem[23734] = 243862817
+mask = 101000XX1010001110000X1X00011X0X0100
+mem[19226] = 7783454
+mem[47036] = 32167689
+mem[54708] = 28465363
+mem[25775] = 13654
+mem[38159] = 226030009
+mem[33886] = 22797977
+mem[47934] = 34738195
+mask = 1010000110110111000101011X0XX1X111X1
+mem[8015] = 1639518
+mem[32888] = 89628061
+mem[19414] = 3293870
+mem[45803] = 3055
+mem[2849] = 517315
+mem[7103] = 1807237
+mask = 0010010X1X110111011010001X010X10X110
+mem[32337] = 14059
+mem[7162] = 22418419
+mem[62068] = 491160015
+mem[52514] = 62411508
+mem[21998] = 16113734
+mem[14899] = 4165873
+mask = 01000101101001100110XX01011XX0X00XX0
+mem[63651] = 706
+mem[27388] = 269141496
+mem[16791] = 90544
+mem[58514] = 2084386
+mem[6512] = 82029923
+mask = XX100X0X1011011X0110X00000011X10XX10
+mem[25492] = 51834825
+mem[39104] = 11018
+mem[31518] = 5721690
+mask = X01001X0101101110X10010111X11X110000
+mem[16817] = 43478591
+mem[49714] = 32182
+mem[7715] = 20391
+mem[36282] = 511726
+mem[2709] = 58604
+mask = 10100001101000XX10001001X110001101X0
+mem[21290] = 96121933
+mem[4581] = 935753770
+mem[10322] = 214308733
+mem[22563] = 955
+mem[21998] = 174320
+mask = 001X010010XXXX10011010010XX01X0X0100
+mem[27908] = 10394
+mem[58731] = 17043901
+mem[12207] = 89277
+mem[50189] = 70951683
+mem[40310] = 1070062397
+mask = X11001X11010X1100110X101X0100X0X01X0
+mem[48661] = 35809
+mem[6512] = 466
+mem[22172] = 9259291
+mask = 001X0001X001010XX001000010X1001X1111
+mem[45021] = 7965
+mem[10414] = 132450
+mask = X11001111X10111001X001010X001X00011X
+mem[22734] = 23954922
+mem[18333] = 522531412
+mem[21084] = 2928539
+mask = 0010000X00110101XX0XX111100100100110
+mem[10793] = 30167743
+mem[54236] = 15119211
+mem[46526] = 34600696
+mask = X010010100X10101X0011X0010000X1XXXX1
+mem[40874] = 107825637
+mem[12207] = 5066
+mem[64061] = 12594443
+mem[14677] = 104815480
+mem[47294] = 27328513
+mem[36871] = 99385
+mem[55732] = 3825863
+mask = 0010X10X101X011101X000011X1100110000
+mem[39282] = 9472566
+mem[19564] = 55941
+mem[8527] = 26084
+mem[10265] = 130187
+mem[6432] = 865842
+mem[20931] = 1702
+mask = 00110X0010X01X1001101X0000XX1XX0110X
+mem[54465] = 11299
+mem[13022] = 487449
+mask = 00100XXX101101101101111010X100100000
+mem[20710] = 1510193
+mem[1742] = 2963920
+mem[15368] = 241191
+mem[48928] = 8865
+mask = 0X10XX0100X10X011000X01101X0X1101110
+mem[33496] = 157963055
+mem[10527] = 1744363
+mem[25912] = 24812738
+mem[53894] = 65229499
+mem[27656] = 195539
+mem[56053] = 84622
+mem[58013] = 503836980
+mask = 00X0000X10X1011X0X10110011111X000011
+mem[21324] = 100568910
+mem[11832] = 25433857
+mem[15696] = 65297
+mask = 00100X010011010110XX01X11XX1001X0111
+mem[1742] = 5701
+mem[50038] = 1734
+mem[3338] = 10181349
+mem[64950] = 715735117
+mem[3094] = 6261
+mask = 01XX01001010X1X101XX000010X111110XX0
+mem[30706] = 34032209
+mem[57669] = 953918
+mem[2368] = 18511
+mem[58246] = 14197924
+mem[12602] = 3821248
+mem[37932] = 73626
+mask = 00X0000110X000011XX0000011100X000000
+mem[44726] = 577645454
+mem[31822] = 2444199
+mask = X0100X01X110001X1X0000X01010X0X00111
+mem[40204] = 167462
+mem[13234] = 334
+mem[55553] = 649450
+mem[18698] = 152213289
+mem[56964] = 1004699
+mem[17434] = 557
+mask = 0X1000011111XX01X01XX10X0100000000X1
+mem[54363] = 171716
+mem[27133] = 813977
+mem[25112] = 478238
+mem[2734] = 2300
+mem[23972] = 7597
+mask = 0110X1X1X011011XX10010X11100X1111X00
+mem[21998] = 2245
+mem[39814] = 10501801
+mem[16186] = 807
+mask = X010000110100001100X0011X11000XX0010
+mem[21976] = 1290104
+mem[45127] = 1447
+mem[19564] = 679
+mem[8927] = 40098844
+mem[43124] = 2060353
+mem[17227] = 11511
+mask = X110X00110X10101111000X0000X10111110
+mem[25530] = 23237
+mem[55910] = 1785756
+mem[38723] = 1821559
+mem[30849] = 4089
+mem[532] = 661
+mask = 0X10010XX01X011X011000011X01X1X001X0
+mem[17212] = 6523
+mem[37424] = 480
+mem[40862] = 449969985
+mem[28474] = 40994780
+mem[21577] = 36128
+mem[39066] = 7501680
+mask = X100X101100X01X001101001X11001111110
+mem[35142] = 186426
+mem[28005] = 1296725
+mem[57552] = 433183
+mem[26566] = 56636
+mem[4581] = 1646680
+mem[35799] = 2658
+mask = 001011010001X00110X00X10000001011X10
+mem[13674] = 62138919
+mem[63552] = 11168
+mem[11669] = 56357099
+mask = 101000XX1010XX0010000X10XX1100010010
+mem[22434] = 34054009
+mem[19261] = 856
+mem[24828] = 7024
+mem[34924] = 648168
+mem[22917] = 9557844
+mask = 10100X0X1011111100X1010000000111100X
+mem[63552] = 11477437
+mem[23072] = 8131648
+mem[19002] = 1064
+mem[23946] = 183
+mem[2440] = 1277
+mask = X0100001101X000X100001001X1X00110110
+mem[55553] = 49381
+mem[25631] = 41125881
+mem[62633] = 590643
+mask = 0X1000011001010001XX11X0010100000000
+mem[10466] = 506832
+mem[23072] = 5583
+mem[45005] = 8337603
+mem[59216] = 7005456
+mask = 0XXX000111111001X0100100001000000100
+mem[19928] = 48311172
+mem[22974] = 815
+mem[34266] = 13786112
+mem[1742] = 9648313
+mem[1094] = 162
+mem[55709] = 31320282
+mask = 0XX0000110100XX1X001001001X001000001
+mem[22346] = 340600
+mem[39104] = 935807
+mem[64441] = 570
+mem[56853] = 3313
+mem[22434] = 1892025
+mask = 01X000X1X0110XXXX1100110000X00101000
+mem[26813] = 23072664
+mem[9142] = 282783543
+mem[29807] = 14754
+mem[56288] = 62827
+mask = 01X0010X1XX001X001X010X011100100X100
+mem[47774] = 352023
+mem[5938] = 132498542
+mem[24828] = 8444211
+mem[55829] = 238313735
+mask = 0010010100X101X10XX0X10X110100XX1X00
+mem[1908] = 30255
+mem[40461] = 1524854
+mem[21752] = 3313
+mem[38177] = 164
+mem[32888] = 20182288
+mem[17656] = 2560835
+mask = 01000101101XX11X0110X10X0000X1XX0000
+mem[18028] = 6424701
+mem[11832] = 73576
+mem[18812] = 15408
+mask = X010X00XXXX1X1100100X1101X1111110010
+mem[31868] = 1008118155
+mem[16970] = 560
+mem[6414] = 659729
+mask = 00100X0110X1010001X0XXX1X00100100X00
+mem[60039] = 1335434
+mem[22051] = 4352989
+mem[23413] = 8881
+mem[5131] = 3574
+mem[31132] = 1822377
+mem[59227] = 3565275
+mem[55044] = 629
+mask = 101001010001X101100X1XX01X01100X1111
+mem[2119] = 6096
+mem[25137] = 4534409
+mem[34466] = 2697336
+mem[24201] = 506176
+mem[25286] = 110343
+mask = 0XX00001101100011000010X101X0X11X100
+mem[29807] = 25323
+mem[12207] = 27513971
+mem[9003] = 1398544
+mem[28341] = 50817018
+mem[30137] = 115
+mem[42114] = 67247621
+mask = 0000X1000010X1X0011010111X0X01X11X10
+mem[48228] = 2010329
+mem[45718] = 71839
+mem[33886] = 136902
+mem[51771] = 2015
+mask = X000000110X101000100000010010X0011X0
+mem[4243] = 33894587
+mem[64857] = 8145
+mem[45718] = 97465094
+mem[53834] = 3359009
+mask = 0010X101000101011X0X01X0101000000001
+mem[24012] = 379049
+mem[39780] = 26758
+mem[59983] = 495835
+mem[37409] = 1160
+mem[52514] = 6321
+mem[27459] = 147
+mem[41942] = 217105
+mask = 00100001100101011X101X0X10111XX10000
+mem[17846] = 10118006
+mem[59737] = 2963
+mem[34644] = 35114650
+mem[13172] = 143244
+mem[5938] = 51096
+mem[44123] = 3352
+mask = 001000X1101101X001X001XX00110101X0X0
+mem[38177] = 2168495
+mem[11075] = 7671
+mem[47735] = 2437651
+mem[57709] = 103925776
+mem[9577] = 253960744
+mem[61912] = 713476954
+mem[10466] = 509335816
+mask = 0X10X00110010100011000001X01001X0001
+mem[46526] = 985771
+mem[63247] = 474051554
+mem[22968] = 581
+mem[29811] = 4967030
+mem[57544] = 438283695
+mem[7042] = 308851
+mask = 001XXX010011X10XX100010X1100X0010100
+mem[22856] = 10167
+mem[25967] = 196716
+mem[17344] = 30111
+mem[3954] = 21193
+mask = 011000XX1101000X00X00101001111000000
+mem[45718] = 22050
+mem[4315] = 28856671
+mem[3954] = 1669054
+mask = XXX000011X11X1000XX011X100X100010101
+mem[25208] = 62883413
+mem[40039] = 460470
+mem[27976] = 317910
+mem[6549] = 3697104
+mem[34078] = 112
+mem[62178] = 479428706
+mask = 0110000111X1X0X1X0100100XXX001XX0010
+mem[532] = 4184102
+mem[25575] = 20376
+mem[59465] = 35723765
+mem[32827] = 2041066
+mem[21963] = 519238
+mem[56441] = 22508
+mask = X0100001101101000100000X0011X01000X0
+mem[34078] = 36026
+mem[12451] = 602257
+mask = 10X0010100X1X10110010010100X0X100011
+mem[52291] = 3349730
+mem[51550] = 12311148
+mem[27235] = 986707194
+mem[7958] = 2162
+mem[36824] = 3705422
+mask = 011X0X0111010000X110000X1X01XX0XX100
+mem[21004] = 1994888
+mem[10900] = 11111
+mem[24854] = 1327
+mem[45320] = 1739644
+mem[29894] = 1918
+mem[62034] = 165719
+mask = 1XX10X10100X1010X1000100X0X10X001X00
+mem[54431] = 68179
+mem[48498] = 269569
+mem[25492] = 53144423
+mem[24130] = 510
+mem[9579] = 22225
+mask = 0X00X101101011X00110X0001001010011X0
+mem[54156] = 597982
+mem[3020] = 27476
+mem[18748] = 105524
+mem[37066] = 28361301
+mem[43484] = 19990814
+mem[18698] = 635178
+mask = X0100001101000X1100X0110XX11111X1000
+mem[44272] = 88008
+mem[11075] = 919
+mem[41491] = 2905
+mem[4898] = 32296
+mem[10607] = 10054
+mem[28252] = 31037

2020/src/main/resources/day15.txt

@@ -0,0 +1 @@
+0,1,5,10,3,12,19

2020/src/main/resources/day16.txt

@@ -0,0 +1,263 @@
+departure location: 45-535 or 550-961
+departure station: 45-278 or 294-974
+departure platform: 46-121 or 138-965
+departure track: 38-149 or 173-949
+departure date: 34-223 or 248-957
+departure time: 32-64 or 79-952
+arrival location: 49-879 or 905-968
+arrival station: 47-306 or 323-973
+arrival platform: 46-823 or 834-971
+arrival track: 30-464 or 486-963
+class: 40-350 or 372-965
+duration: 47-414 or 423-950
+price: 45-507 or 526-956
+route: 42-779 or 799-970
+row: 26-865 or 872-955
+seat: 43-724 or 739-970
+train: 25-914 or 926-958
+type: 33-205 or 218-965
+wagon: 43-101 or 118-951
+zone: 45-844 or 858-970
+
+your ticket:
+173,191,61,199,101,179,257,79,193,223,139,97,83,197,251,53,89,149,181,59
+
+nearby tickets:
+949,764,551,379,767,144,556,835,638,591,653,872,198,825,690,527,260,396,873,333
+438,627,99,622,408,671,695,561,695,121,706,144,55,985,566,706,255,595,680,407
+879,876,665,928,874,436,766,328,620,267,995,54,430,503,86,936,489,305,64,688
+613,812,756,258,341,765,91,551,859,379,447,842,148,501,293,766,93,532,939,406
+349,340,670,248,813,557,249,949,506,656,100,19,204,409,944,659,777,843,712,801
+438,52,529,556,672,115,570,633,820,770,603,837,260,251,723,621,381,182,494,431
+948,673,202,330,552,258,406,184,177,239,774,185,638,386,834,608,835,636,805,92
+573,643,267,378,178,821,442,141,872,826,565,626,667,860,405,610,407,688,705,695
+818,724,446,459,145,373,859,346,702,441,446,753,320,426,664,177,619,712,739,342
+607,499,226,80,719,682,556,486,346,221,597,936,573,84,760,671,395,413,454,768
+743,504,830,195,413,698,93,375,565,695,947,636,602,681,436,265,614,604,632,706
+463,353,944,569,175,535,616,452,141,621,84,335,302,275,550,438,173,617,843,645
+685,400,777,752,839,86,180,754,231,450,342,341,440,57,271,202,494,591,223,707
+838,147,937,451,96,265,488,345,334,871,767,450,340,576,816,335,143,445,339,379
+502,566,121,743,99,909,876,265,204,799,566,387,672,102,713,559,773,770,571,609
+428,712,575,759,708,272,629,862,569,856,402,82,424,837,336,643,841,944,603,436
+273,987,944,534,862,943,267,741,562,327,193,838,822,933,860,933,459,811,622,383
+423,937,320,374,801,942,490,257,646,724,558,507,198,601,713,719,667,260,585,948
+404,679,328,916,688,615,345,688,556,146,452,306,89,742,808,141,816,85,938,457
+180,335,648,810,119,202,393,268,921,177,92,462,605,615,248,599,394,303,269,599
+941,261,695,643,381,830,753,705,84,694,305,61,556,256,599,653,388,566,626,759
+148,340,708,139,625,680,713,695,583,356,182,457,458,95,841,496,591,347,392,670
+534,434,615,686,348,621,832,275,380,667,811,590,389,585,528,652,862,617,778,535
+81,653,435,681,584,455,261,928,121,863,263,807,599,593,691,320,495,329,879,380
+739,632,692,639,702,94,274,910,707,758,196,934,490,189,169,333,807,396,448,719
+590,588,570,617,910,928,304,663,531,470,203,505,277,669,841,593,668,693,338,671
+938,259,221,406,579,390,619,327,824,601,502,529,573,912,930,396,940,139,501,819
+633,326,149,590,618,581,583,195,755,678,746,717,527,326,557,775,330,518,807,192
+438,722,427,758,324,251,757,753,297,300,438,304,588,633,254,823,835,766,977,195
+335,430,937,298,266,258,331,551,747,644,575,120,373,629,652,583,777,131,804,941
+427,663,220,864,378,80,945,695,7,584,679,375,566,176,300,631,932,558,639,681
+577,644,678,146,396,443,94,488,670,691,260,931,834,755,577,395,420,94,57,664
+660,574,799,666,748,858,393,603,120,391,561,138,631,578,463,344,382,747,699,102
+676,866,348,927,187,452,615,943,52,752,749,707,699,615,840,563,653,271,844,223
+573,453,587,838,260,802,768,303,382,817,429,486,586,184,502,156,486,486,816,203
+433,285,809,588,756,504,121,598,265,273,666,769,799,405,218,189,221,191,681,712
+612,63,678,529,775,684,531,838,617,572,555,386,628,272,765,603,23,393,743,753
+775,704,877,81,597,529,579,699,527,662,652,456,801,863,94,335,679,820,415,714
+714,306,176,652,492,446,325,580,647,149,554,708,504,327,624,245,702,506,843,756
+173,294,877,499,714,200,253,808,661,664,14,879,146,533,693,527,424,660,274,204
+564,434,116,585,801,617,764,860,376,185,639,698,863,620,753,253,253,182,93,491
+685,559,336,773,906,568,936,270,938,397,95,264,95,119,266,21,250,709,528,591
+174,57,400,298,350,799,139,603,686,586,601,663,527,248,560,613,838,742,698,225
+335,275,260,293,142,266,611,685,400,840,337,584,276,770,698,191,665,668,685,50
+706,97,296,848,85,63,600,191,120,490,905,776,581,435,265,530,602,61,596,646
+327,663,656,436,773,760,255,609,655,452,439,490,254,939,327,815,600,235,507,811
+334,58,143,417,630,455,454,390,327,339,906,494,739,188,260,842,298,740,680,662
+398,346,388,443,680,563,666,666,438,764,559,926,909,948,437,72,493,809,397,381
+176,272,305,197,346,610,179,253,506,413,174,506,647,689,338,570,873,929,317,820
+553,946,409,562,258,398,187,429,819,104,909,571,534,266,739,258,643,60,601,379
+678,905,187,870,253,184,489,414,690,184,175,741,197,626,388,204,612,637,219,259
+346,665,800,614,94,264,658,811,374,640,666,295,449,976,563,696,695,675,527,694
+821,387,760,379,635,251,51,911,54,543,710,808,453,873,746,326,258,306,411,764
+186,487,378,937,559,575,382,931,664,697,534,576,715,940,984,628,409,651,676,665
+502,393,59,176,760,326,106,378,96,573,344,174,652,294,650,703,402,297,185,52
+834,433,613,554,764,839,493,752,185,254,388,83,769,621,623,17,607,330,529,690
+818,21,649,258,186,258,775,449,454,912,61,603,578,578,410,603,770,254,535,269
+757,615,389,650,749,630,560,257,269,822,412,740,759,941,59,835,522,462,494,531
+570,764,174,296,499,867,277,700,820,380,663,718,756,462,496,564,562,698,265,147
+500,680,271,610,396,820,250,827,87,768,671,906,706,865,300,560,815,691,745,907
+385,346,945,504,411,291,566,530,677,685,95,659,393,692,683,822,553,640,753,204
+492,821,178,186,488,140,411,739,135,582,445,776,222,699,656,633,879,807,591,428
+635,931,935,304,84,634,416,670,611,773,64,821,570,389,504,671,927,773,333,906
+807,626,617,932,187,402,581,640,693,551,458,583,444,126,695,711,221,327,835,947
+679,750,506,101,705,335,568,615,550,388,497,940,861,260,714,776,333,993,388,753
+197,656,802,589,341,993,378,390,347,403,927,593,928,673,747,554,680,775,342,639
+639,76,742,603,424,219,754,458,257,350,186,805,193,764,390,627,749,342,433,439
+629,704,941,304,637,860,661,388,139,404,945,647,573,840,886,149,667,382,399,747
+588,195,763,438,835,707,220,268,838,574,402,980,372,347,92,205,261,86,681,86
+266,739,816,2,585,701,841,600,590,497,204,743,383,810,140,617,864,770,705,300
+62,673,949,391,765,184,305,528,101,192,708,275,561,649,606,527,687,315,197,633
+433,419,644,531,626,534,300,263,265,257,618,303,631,194,675,684,694,669,861,721
+692,764,408,248,459,176,691,179,252,618,685,456,431,119,948,334,104,433,581,85
+333,341,627,766,620,263,720,118,690,914,641,204,189,722,197,912,612,65,930,906
+711,387,815,619,202,592,613,221,765,403,715,939,844,715,537,204,176,683,656,746
+91,927,559,933,197,406,641,658,391,199,339,272,383,932,829,196,739,755,720,430
+864,603,696,455,752,374,703,98,508,119,756,331,758,396,600,258,842,191,350,526
+633,121,659,428,179,562,715,821,404,260,587,760,570,707,711,566,570,642,824,560
+774,22,878,300,676,763,95,931,268,574,82,490,218,937,602,940,665,97,60,566
+223,632,412,385,909,707,336,937,808,743,775,705,99,984,380,384,585,99,337,724
+947,709,610,646,665,593,278,755,556,606,189,679,403,377,677,84,392,108,638,651
+262,424,498,429,623,385,496,138,696,693,258,454,273,868,533,834,257,100,459,99
+817,56,51,544,631,258,101,384,841,906,637,681,772,189,305,181,200,608,839,932
+141,409,907,665,54,177,349,173,4,448,843,717,380,253,598,140,570,820,502,948
+184,920,382,142,342,530,612,431,196,710,101,704,398,862,612,377,173,876,218,757
+811,800,437,212,756,425,584,616,384,119,839,334,934,600,534,178,86,624,532,711
+938,334,603,142,54,695,5,874,779,700,632,99,942,223,661,579,807,707,614,602
+665,296,52,621,320,434,570,506,687,908,905,714,185,683,758,617,644,82,95,716
+656,685,176,452,385,195,375,87,814,290,52,683,413,456,457,656,143,634,174,659
+756,765,269,251,263,616,715,637,760,454,533,489,52,251,418,306,202,838,180,198
+877,557,220,115,249,774,63,97,348,119,940,444,486,616,926,82,256,585,619,772
+758,337,98,360,296,453,739,807,390,634,497,820,381,179,349,714,676,256,765,60
+50,619,639,941,571,66,267,454,561,379,143,452,554,393,759,149,148,875,397,640
+274,523,275,683,384,620,94,811,79,839,776,589,507,194,430,331,95,606,631,88
+165,121,84,575,201,409,82,800,401,52,301,493,325,691,503,336,555,774,706,251
+576,119,938,333,462,449,339,382,266,808,145,763,459,810,910,342,640,199,617,520
+408,762,183,409,763,59,333,932,323,59,560,703,306,856,269,652,298,98,488,587
+344,948,221,749,835,316,779,860,56,205,723,712,553,346,721,305,494,338,186,819
+184,773,66,619,554,807,120,437,774,645,272,89,710,378,659,403,253,533,396,715
+610,579,565,758,336,817,690,406,289,724,618,200,188,486,529,488,841,582,101,671
+14,325,750,801,182,263,858,550,710,391,633,768,265,601,910,687,429,689,337,402
+200,653,645,875,527,382,348,424,909,810,186,426,60,682,90,83,121,595,116,834
+305,300,686,769,590,90,764,551,426,863,381,506,721,612,627,323,177,4,704,529
+416,277,175,662,688,698,437,586,777,425,533,858,222,60,140,719,493,558,695,768
+863,268,739,653,512,779,437,248,300,451,195,874,436,772,332,589,183,746,94,756
+621,97,575,770,327,803,659,397,346,907,720,862,770,436,520,694,445,691,810,553
+436,642,811,221,758,406,362,442,501,374,684,53,660,146,205,383,677,597,430,201
+926,439,650,266,578,486,189,819,539,760,872,560,910,589,821,605,694,142,762,180
+499,436,417,535,718,674,698,174,696,96,440,490,304,199,406,559,185,328,573,685
+92,803,711,603,721,185,450,676,809,132,569,427,596,248,745,498,574,388,879,667
+253,339,295,805,61,620,140,376,332,712,94,841,528,621,686,756,307,610,255,533
+175,429,628,629,407,260,647,276,619,666,820,145,611,380,750,21,91,629,62,445
+580,750,665,742,935,591,405,643,195,295,592,773,455,545,449,347,701,912,143,380
+698,948,527,822,713,52,683,671,759,767,684,184,817,392,983,60,396,599,907,342
+138,630,6,583,526,401,187,945,836,690,841,531,563,910,408,779,644,660,683,374
+280,669,596,815,346,497,740,493,596,767,675,248,817,222,860,457,938,435,121,120
+144,631,771,437,616,745,668,604,142,862,550,324,570,345,124,622,93,59,619,79
+393,442,549,374,222,447,601,753,373,455,440,582,751,435,596,691,187,686,179,347
+298,616,59,623,447,51,909,755,71,709,701,406,697,373,875,754,573,332,754,767
+709,201,430,81,608,688,939,496,569,260,711,935,943,304,87,617,744,165,487,626
+294,446,946,700,392,880,758,687,656,751,395,407,266,443,61,629,820,458,434,179
+648,669,942,695,587,813,803,254,173,633,376,14,574,702,711,654,761,740,297,597
+435,774,935,592,779,494,635,406,573,723,994,139,772,562,707,637,839,635,380,82
+413,630,657,637,328,614,574,741,687,445,413,777,202,244,200,682,506,644,348,806
+575,712,119,720,695,920,679,300,488,583,933,410,555,762,90,192,138,252,556,95
+813,457,628,648,696,403,382,806,338,183,344,146,799,315,497,401,328,63,747,198
+622,652,329,198,710,442,178,754,817,744,675,819,815,922,764,659,934,582,61,302
+392,533,619,311,299,593,707,876,331,714,590,447,690,753,463,914,526,822,698,655
+665,754,602,614,646,594,550,619,560,393,428,747,634,271,274,339,627,826,909,585
+942,809,614,568,815,344,514,779,927,580,564,909,347,838,403,752,618,566,530,443
+692,820,746,88,640,933,118,183,586,744,745,268,616,250,581,639,615,858,386,984
+87,631,934,841,613,249,691,97,336,886,270,613,634,692,669,257,558,399,306,93
+930,717,669,275,189,258,703,272,602,718,530,331,218,660,271,834,653,836,408,421
+383,804,698,441,417,403,940,858,700,875,770,198,714,435,569,486,487,177,80,949
+202,142,864,348,426,537,204,615,681,676,933,178,816,396,175,769,423,766,879,593
+592,309,804,638,197,759,426,577,441,409,928,571,800,506,275,768,689,333,932,937
+509,607,248,556,575,424,435,942,490,678,563,677,374,295,629,666,252,337,578,745
+827,754,62,747,686,627,671,98,708,686,407,599,835,205,805,534,741,201,384,189
+623,434,15,496,89,655,146,190,816,63,423,496,635,948,910,934,81,641,437,614
+495,52,634,181,376,500,680,57,497,717,14,679,148,406,661,452,906,264,526,401
+97,188,330,948,374,251,633,639,434,777,913,529,679,605,76,625,550,939,762,445
+859,675,304,473,427,261,640,196,647,350,686,58,202,908,912,174,447,590,275,401
+372,748,687,696,381,201,569,676,147,516,338,428,394,148,391,338,819,766,707,585
+769,449,505,602,814,644,272,945,773,424,444,811,417,709,100,862,596,628,450,346
+426,228,424,384,257,681,383,639,554,551,701,942,95,100,842,396,909,609,626,622
+397,589,766,277,459,819,85,807,295,488,449,399,339,532,378,420,144,750,841,145
+683,626,645,75,265,267,773,550,595,604,328,747,262,647,201,590,201,906,932,445
+618,932,345,435,532,276,277,532,813,459,764,327,979,388,634,914,452,396,391,64
+668,53,721,716,591,433,265,190,763,327,693,926,648,84,98,863,770,621,638,977
+685,834,490,686,402,768,575,741,930,582,724,389,551,22,838,665,627,460,590,261
+225,384,397,667,843,411,673,56,120,697,220,623,376,101,305,185,807,698,637,599
+687,375,914,602,806,372,491,560,608,573,80,758,632,932,599,610,327,695,944,987
+676,637,860,718,698,193,71,187,684,335,596,340,673,81,860,630,877,340,948,273
+249,716,674,400,553,567,698,505,834,85,424,597,706,581,740,3,100,804,652,274
+837,836,437,872,220,502,375,643,328,490,0,662,267,648,222,344,399,555,944,946
+121,717,463,643,406,261,391,646,181,641,336,651,86,275,494,607,353,84,384,434
+650,252,13,259,334,840,601,249,199,607,258,629,259,678,611,100,696,339,765,56
+449,692,80,752,778,675,496,940,934,98,189,552,679,629,110,277,192,399,696,739
+190,589,432,913,606,839,121,82,358,384,701,760,618,927,838,912,139,937,326,328
+935,276,427,859,504,758,716,753,276,935,672,457,937,800,192,356,101,679,699,757
+249,830,752,560,801,199,594,722,875,637,99,579,740,762,58,710,149,657,218,605
+935,949,653,453,949,930,802,501,768,275,905,500,177,217,298,768,423,655,187,568
+608,87,296,220,982,200,676,661,147,931,496,600,333,683,192,462,691,400,812,198
+770,435,844,907,402,186,706,433,532,656,696,837,688,774,218,826,575,324,441,874
+680,679,223,459,803,100,300,577,636,751,383,879,404,621,646,306,827,400,413,808
+805,991,623,83,626,615,505,682,757,491,941,295,266,487,807,221,526,914,686,193
+694,622,82,566,187,944,390,431,433,659,837,937,345,513,504,179,306,324,610,601
+660,456,823,760,914,52,773,272,251,815,412,683,266,819,119,111,683,593,487,426
+101,278,712,51,187,710,270,598,219,940,612,182,389,999,341,325,626,302,770,572
+913,537,624,602,584,928,630,862,275,179,803,913,928,805,530,388,445,593,629,294
+111,668,811,864,632,261,929,306,451,665,503,439,88,817,570,874,838,555,304,349
+692,263,255,192,739,621,768,262,318,373,459,487,680,704,799,583,428,447,705,834
+306,406,813,692,107,89,177,597,711,223,408,862,628,603,582,176,142,83,248,657
+395,566,620,663,335,557,385,599,341,810,459,706,805,873,305,875,262,418,613,553
+840,563,100,626,823,186,600,668,945,314,323,442,99,705,684,638,859,564,669,583
+714,334,464,911,406,196,683,931,62,301,98,743,450,416,182,860,197,840,634,599
+774,948,146,893,944,775,339,655,120,176,650,277,712,707,81,140,377,573,487,630
+685,697,143,167,668,773,946,423,859,766,266,696,375,580,264,640,615,807,148,302
+584,124,649,752,220,202,449,935,97,189,64,762,927,432,432,714,80,914,426,188
+836,176,180,839,740,420,54,946,934,149,384,603,743,564,678,662,720,377,461,821
+443,837,385,124,374,267,555,746,459,823,935,586,180,659,632,662,660,934,530,949
+940,874,96,101,801,227,948,553,589,744,698,656,272,278,276,626,337,452,764,702
+430,558,528,533,618,710,321,277,761,937,277,205,914,405,765,779,435,306,119,624
+176,843,763,380,908,190,931,769,327,491,333,463,89,172,838,349,809,675,505,632
+437,764,275,681,911,752,634,340,621,55,491,400,555,751,143,385,575,552,551,357
+749,179,843,429,61,669,426,709,624,74,264,333,631,934,808,196,200,944,526,176
+368,195,441,183,251,699,705,802,295,770,762,819,254,203,669,578,298,600,89,660
+376,178,807,375,628,691,685,299,683,333,824,447,506,305,779,778,62,874,182,303
+536,744,502,769,182,299,184,344,803,619,504,86,769,638,811,836,745,597,614,626
+451,430,651,761,60,844,118,591,776,165,451,573,772,839,96,652,878,807,676,930
+526,589,622,768,773,259,304,262,261,54,249,555,426,865,120,520,54,706,430,323
+97,844,261,260,633,739,761,805,179,178,566,754,330,911,311,58,698,101,276,741
+564,379,453,342,193,676,99,278,443,278,325,257,487,744,299,538,606,335,438,761
+740,97,612,392,272,264,724,252,117,708,818,562,810,675,196,372,749,454,499,560
+779,990,410,448,696,391,672,441,146,581,554,694,768,383,405,692,675,776,936,342
+219,140,563,457,455,326,608,755,720,680,56,412,459,687,925,98,183,802,841,740
+322,81,594,687,52,61,427,173,626,673,863,945,174,594,200,688,770,876,768,553
+815,611,595,454,441,681,526,297,942,301,447,426,100,755,191,645,203,374,276,77
+86,385,659,621,584,684,51,816,347,499,603,488,396,67,432,342,687,816,94,260
+437,778,345,504,574,862,609,843,667,251,704,84,258,457,647,429,875,743,814,833
+676,672,942,197,505,390,568,719,931,947,276,120,824,188,594,808,563,876,775,909
+762,752,940,230,341,118,623,404,716,120,768,101,834,176,755,486,141,184,577,767
+721,676,437,454,391,303,810,220,191,178,937,190,56,714,455,299,82,368,802,740
+60,462,575,865,250,172,931,347,53,54,813,81,295,452,561,937,776,81,705,669
+670,772,676,945,432,522,347,489,620,680,749,194,384,637,201,613,605,630,562,529
+99,599,660,263,304,431,427,101,323,863,426,462,83,649,243,385,497,759,777,93
+433,608,512,425,329,530,602,945,173,875,638,494,770,670,940,836,262,702,659,873
+453,391,428,348,907,687,462,324,941,381,613,204,395,896,946,381,779,810,841,705
+265,905,560,54,681,765,682,88,568,273,939,493,57,266,342,6,612,633,550,337
+930,534,204,753,934,846,569,682,745,934,403,906,272,677,719,776,754,534,556,173
+486,809,755,763,441,396,689,415,385,490,145,304,271,204,375,344,800,92,872,694
+489,425,688,573,743,564,295,652,257,707,267,173,758,365,739,265,684,527,860,655
+299,646,180,52,697,721,766,574,151,762,376,182,407,196,80,873,188,329,248,448
+431,381,779,393,223,575,408,858,616,415,85,707,749,264,489,390,597,779,185,937
+457,168,219,54,90,119,744,332,52,862,941,818,554,703,820,464,742,554,331,914
+809,529,444,455,91,11,843,862,428,632,707,195,571,747,905,187,328,864,393,629
+295,720,375,80,928,551,683,567,418,341,685,632,711,98,218,811,622,583,487,382
+804,113,92,442,296,669,390,218,691,263,492,643,80,669,501,329,566,803,191,879
+805,609,749,808,563,141,612,724,266,666,678,491,566,687,940,338,704,544,528,501
+556,879,356,876,607,183,577,811,344,586,616,767,622,865,859,497,429,580,776,254
+130,276,393,927,190,455,908,329,676,818,572,204,760,801,146,946,205,95,579,139
+423,862,374,93,685,844,101,811,461,81,617,175,643,287,271,179,180,101,595,774
+256,89,407,563,759,665,844,563,932,91,406,597,685,389,658,348,81,295,251,309
+189,743,376,86,333,394,593,773,562,589,668,646,565,477,669,196,581,297,652,98
+769,807,569,559,976,651,266,86,258,934,334,635,560,761,61,188,497,680,571,823
+931,752,461,705,394,128,764,569,297,932,450,665,59,440,694,710,753,627,559,388
+775,631,390,87,772,654,561,145,401,917,175,912,693,64,766,606,590,427,701,688
+594,740,203,748,461,294,822,642,96,610,907,805,647,582,359,719,632,377,748,943
+65,561,677,645,495,99,223,592,596,402,385,746,328,392,583,336,487,684,304,935
+260,679,451,176,596,581,938,679,456,762,464,859,565,715,820,752,530,928,248,15
+218,529,596,297,876,651,557,659,506,562,341,96,3,564,199,400,503,647,707,182
+613,195,929,818,823,808,265,63,498,686,583,97,88,650,866,640,141,461,594,119
+219,873,720,388,835,143,205,602,339,576,448,388,255,731,558,305,644,672,303,255
+526,652,256,520,263,182,263,686,382,581,250,255,559,500,248,566,807,273,622,944
+464,802,408,702,829,299,397,414,403,565,407,412,759,503,565,59,652,758,650,427
+602,57,873,828,564,554,565,435,303,590,323,388,138,528,94,350,175,634,410,63
+254,500,57,86,984,253,751,822,202,395,181,719,812,940,625,640,615,749,437,610
+326,631,940,409,753,368,438,202,553,446,592,876,818,684,617,843,753,575,800,695

2020/src/main/resources/day17.txt

@@ -0,0 +1,8 @@
+##..#.#.
+#####.##
+#######.
+#..#..#.
+#.#...##
+..#....#
+....#..#
+..##.#..

2020/src/main/resources/day18.txt

@@ -0,0 +1,372 @@
+6 + (3 + 6 + 5 * 4) * (4 + 3) * 8 + 6 + 6
+7 + 6 + (9 + 4 * (8 + 7 * 8 + 2 * 7 * 9) * 9 + 5 + 3) + 6 + (7 + 5 + 7 * 9 + 9) * ((4 + 9 * 3 * 4 * 3) + 6 * 8)
+3 + (6 + 4 * (8 + 4 * 3 + 8) * 7 + 5 + 4) * 3 * 2 + 5 + 4
+2 * 4 + 4 + (5 * 9 + 3 + 9) * 6 * 2
+3 * 7 + 4 + 6 * ((8 * 9 * 2 * 9) + (9 + 3 * 6) + (3 + 4 * 8 + 2) * 2) * 2
+(9 * 2 * 7 * 5) * (6 + 3 * 3 * 3) + 5 + 9
+(7 * 2) + ((7 * 3 * 7 + 2) * 3)
+2 + ((4 * 8) + 6 * (3 + 5) * 4 * (6 * 7) * 4) * 8 + (7 * 5 * (8 * 3 * 8) * 5) + 6 * 2
+(2 * 4 + (4 * 2 * 2 + 3 + 8 * 5)) * (3 * 4 + 6 + 7 * 5) * 5 * 5 + 6 * 7
+4 * 8
+5 * (5 + (3 + 2 + 7 * 6)) + 4
+(8 * 2) * 8 * 9 * 7 + (9 * 6 * 6 + 4) + 2
+2 * (3 * 8 + (3 + 5) + 4) * 7 + 8 + 3
+6 * 2 * 5 * 9 * 4
+(5 + 5 + 5 * 2 + 3 + 8) * 5 * 2 + 9 + (8 + 8)
+5 + 6 + 3 * (2 * (4 + 9 + 7 * 8) * 9 + 4 + 8) * (5 * 7 * 9 * 5 * (3 + 2 * 6 * 4))
+3 + (2 * 4) + 8 * (3 + 5) + 9 * 8
+((4 * 7 + 5 * 2 * 3 + 9) + 4 + 6 * 9 + 6 + (6 + 9)) * 4
+2 + (2 + (2 * 6 * 3 + 2 * 6)) * 9 * 7 + (7 + 7 + 2) + 5
+7 + 4 * 4 * 4 * 8 * 7
+6 * (5 * (8 * 8 + 7) * (6 + 5 + 6 * 3 * 2) + 4) * 9 * 2 + 7
+(8 + 8 * (6 * 3 * 2 * 8 * 5) * (2 * 3 * 5 + 2 * 6)) + 5 + 4 * (4 * (7 * 9 + 8 * 6) * 7 * 9)
+9 * (2 + 7 + 3 + 7 * 9) + 3 + 6 + 7 + 4
+9 * 9 * (4 + 8 + (9 * 8 + 6 + 2 + 6 + 3) * 4 * 9 + 5)
+6 + 9 + 2 * ((6 + 9 + 5) + 8 + 6 + 5 + 5 + 6) + 7 * 8
+((3 * 2 * 5 + 3) + 8 + 7 + 9 + 2 * 8) * 9
+7 + 4 + 8 * 4 + 4 + (4 * (7 + 8 + 6 * 6 + 2) + (7 + 9 + 7 + 4) * 9 + 9 * 5)
+8 * 8 * (2 + 9 * 3 * 5) + ((4 * 5 + 3 + 8 * 6 + 3) * 5 + 2 * (6 + 8 + 6) + 4) * 2
+((3 + 4 * 2 * 9 * 2) + (8 * 3 + 7) * 7 + 6 + (4 * 7) * 5) + ((2 * 8 + 5 + 7 * 8 * 9) + 7 + 6 * 5)
+6 + 4
+2 + (6 * 9 + 8 + 2) * ((7 * 5) + 6 * 9 * 7 * 7) + 3 + 6
+((6 * 8 * 7 * 2 * 6) * 9 + 6 * (6 * 8) + 9) + 3 + 9
+9 + (8 * 9 * 9) + (4 + 8 * (2 + 9 + 4) + (3 + 9 * 4 * 5 * 8 * 3) * 9 + 2)
+3 * 2 * (3 + (4 + 3 + 3 * 5) * 4 + 3 * 8)
+2 * 5 + ((3 * 9 + 6 + 7) + (2 * 6 * 4 * 2 * 5 * 7)) * 5
+3 + 8 * 9 * ((3 + 4) + 2 + 9 * (4 * 4) + 3) + 3 + (5 + 3 + 5)
+(4 + 4 * 7 * (3 + 4) * 2) * 8 + (4 + 8 * 9 * 9 + 4) + 2
+(3 + 7 + 9 * 6 * (8 * 4 + 6 + 4 + 5 + 7) * (3 + 9)) + 3 + 2 * 4 + 7 + 8
+(3 * 4 * 9) * 2 + 4 + 6 + 2 * ((8 + 2 + 5) + 5)
+4 * ((3 + 9 * 2 + 4) + 6 * 9 + 6 * 5 * 3) * 9 + 7 * (9 * 9)
+(8 * 4 + 3) + 7 * 6 * 4 * 3 * ((6 + 5) * 6 * 2 * 6)
+5 * (7 * 5 * (7 + 2 + 6 * 5 + 8) + 3 * 2) * 2 + 3
+7 * 9 + (4 + 8 + 7) * 3 * (9 + (8 * 2 * 7 + 8 * 7 * 6) + 3 * 8 * 9)
+8 * 3 + (2 + 9 + 8 * 5) * 8 * 2 + (4 * 8 * 7 + 5)
+5 + 4 + (2 + 3) * 9 + (3 * 7 * 9 + 3) * 4
+4 + (8 * 8 * 5 * 4)
+9 * 9 + (5 + (9 * 5 * 2 * 5)) * 9
+(3 * (6 * 7 * 8) + 4 * 4 + (2 * 2 * 9 * 4)) * 7 * 4
+4 + (8 * (7 * 6 * 2 * 9) + 5 * (3 * 7 + 6 * 7) * 7 * 8) + (2 + 2 * 4 + (8 + 5 + 5 * 3 + 2 + 5) + (2 * 9))
+2 * 7 * (3 * 8 + 2 * 7) * 2 + 8 + 8
+3 + (2 * 8 + 2) + 9
+((6 * 3 * 4 * 9 * 7 * 4) + 2 + (7 * 6 * 3 + 6) * 9 + (5 + 3 + 5 + 7)) + 6 + 8 + 3
+4 * 6 + (9 + 6 * 4 * 9 + (5 + 3 + 5) + 4) * 2 + 8 + 9
+(7 + 2 * (4 * 5 + 5 * 3) * 8) * 4 * 2 + 7 + ((6 + 8 * 8 + 2 * 4 + 5) + (9 + 3))
+6 + 6 + 9 + 9 + (4 + (2 + 4 + 8 + 3 + 3) * 8 + 3 * 2) * 3
+5 * (4 + 4 + 4 * 7 * 4) + 7 * 4
+5 * ((5 * 8 * 9 + 2 + 8) * 6 + (5 + 3) * 4 + 8 + 3) * 8
+5 + (2 * 7 + 2 * 6 * 3) + (2 * 3 * (3 + 6 * 9)) * 4
+((4 + 6 * 3) + 6) * 6
+3 * 4 + (9 + (4 * 9 * 9 + 6 * 2) + 4 * 9 + 2) * 3
+7 * 9 * 9 + 7 * 3 + 9
+6 + 2 * 4 + ((9 + 5) + 4)
+(7 * 2 * 6) * 6 + (5 * 3) + ((7 * 4) + (2 * 8 + 6 + 9) * (7 + 4) + 8 + (2 + 7 + 6 * 3 * 7) * 3) * 3 + 2
+7 * (7 * 3) * 7 + (6 * 2 + (8 + 6 + 5 + 8 * 4 + 9) + 4 * 2)
+(6 + (9 * 4 * 9 + 9 * 7)) * (4 * 5 + 6 + 2 + 6 + 9) * 6
+((6 * 7 * 3) * 6 * 9) + (8 * 4 * 8) * 3 * 9 * 6
+5 * 6 * 6
+9 + (3 * 8 * (5 + 9 * 4)) * (5 * 2 + 4 * 6 * 3)
+(8 * 5 * 2) * (8 * 3) + 4 * 6
+((8 * 8 + 3 * 5 + 6) * 8 * 5) * 5
+(3 + 5 * 7 * (2 + 4 + 3) + (5 + 4 + 7 * 3 + 9) + 6) * 3
+7 + 2 * 7 + ((6 * 9) + 2 + 9 * 2 * 5) + 2 + 7
+5 * (5 + 8 * 3 + 9) * 4 * 9 * 2
+(9 * 3 * 3 * 9 + 5 * 9) + 8 * ((2 * 7 + 5 * 3) + 8 * 9 + (6 * 6 + 9) * 6) + (8 + 6 * 7 * 9)
+8 * ((2 * 4 + 6 * 6 + 9) + 7 * 4) * 6 + 5
+3 * 9 * 8 + (4 + (2 * 7 * 6) * 9) + 7 + 9
+2 * (6 + 5 * 7 * (8 + 8 * 9 + 9 + 3 * 8) + (6 * 6) * 4) + 5 * 7 + 3
+6 + 2 + (3 + 7 + 8 * 2)
+(9 + 2 + 6 * (9 * 9 * 7 * 5 * 6 + 6) + (2 * 2 * 5 * 7)) + 3 + 4
+2 + 8 * 5 + (5 + 4 + 7 * 3 * 6 * 9) * 5 * 9
+(4 * (2 * 6 * 8) * 9 * 9 + 6) * 8 * 9 + 6 * 4 + 5
+4 * 4 * 4 * 4 + 5
+(2 * 2 + 3 + 2 + 7 + 6) * (4 * 7 + (2 * 5))
+3 * 7 + 8 + 9 + 7 + 9
+((2 + 6) + 4) * (8 * 5 * 3 + (5 * 4 * 3 * 9) * (4 * 9 * 2 + 2 + 5 + 9) + 8) + 2
+5 + 6 * (3 + (3 + 8 + 5) + 7 + 6 + 5) + 9 + 9
+(9 + 3) + 3
+9 * (3 + 3 * (8 * 7) * 8) * (6 * 8) + 4 + ((4 * 2 + 6 + 5) + 8)
+(4 * (6 * 8 + 3 * 3 * 9 * 6) + 6) * 5 * 3
+6 + 4 + 4
+(5 * 9 + (6 + 2 + 6) + 5 + 2 + 9) + (6 * 8) + (2 * 5)
+(4 * (4 * 3 * 2 * 4) + 5 + 6) + 4 * 9 * (4 + (9 + 7) * 8) * 6 * 9
+4 * 3 + 5 * 2 * (2 * 8 * (6 + 8 * 7)) + 6
+7 + 4 * 8 * 4 * (6 * 5 * 2 + 8 * 7)
+8 * 2 * (7 + 6 + (4 * 7 + 8 * 5 * 2) + (3 * 7) * 8) * 8 * 4
+(7 * 9 + 4 * 2 + 6 * 7) + (8 + 7) * 9 * 9 * 6
+(6 * 8 + 5 + 9 * 2 * 3) * 4 * 4 * ((7 + 7) * 8 * 3 + (9 * 2 + 7) * 2 + 3)
+3 * ((2 + 8 + 9 * 4 * 5 * 4) * 5 + 8 + 8) + 5 + 5 * 2
+4 * 4 * (6 * 4 * (5 + 2 + 9 + 5 * 8)) * 6
+9 + 4 + (7 * 3 * 4 + 9) + (8 + 2 * 9 * (2 + 9 * 2 * 7 + 7)) + (5 + 4 + (9 + 8) * 4 + 7) * 6
+(3 + 5 + 4 + (2 * 3 + 7 + 2 + 2 + 5)) * (6 + 3 * 5 + (9 + 2 + 4 + 5)) + 7 * 8 * 6
+4 + 3 + ((2 + 9 * 3 * 5 + 9 + 7) + (3 + 3 * 8 + 2 + 6) * 4 + 5) * 8 + 6 + 2
+4 * 9
+5 + (2 + (5 * 6 * 3 + 9) * (8 + 7) + 9 + 4) * 4 + 2 + 3
+(6 + 6) + 8 + 4 * (3 * 9 * 7 * 9 * 8) * 4 * 8
+(5 + 7 + 8 + 5 * 4) + 4 * 6 + (2 * 4 + 8 + 9 + 2)
+(9 + 2 * (2 + 3) + 5 * 3) * 2
+7 + 9 + 3 + 3 + (4 * 9 + (6 * 5 + 8 * 9) + 7 + 4) * 4
+6 + (2 * (5 + 8 * 3 + 5 + 7 * 2) * 8) * ((2 + 9) * 6)
+7 * (3 + 2 + (9 + 9 + 7 + 5 * 7 * 9) + 4)
+(5 + 6) + 8 * 5 * 6
+8 + (2 + 7 + 4 + 6 + (5 * 7 + 6 + 2 * 5 * 6)) * 3 * 2
+(5 * 4 * 4) * ((8 * 3) + 7 * 6 * (7 * 6 * 3 + 8)) * 5 + (5 * 9 + 2 * (3 + 6 + 9 * 5 * 9 + 2) + 2 + 6)
+3 + 9 * 3 + 7 + 6
+((9 * 7 + 7) * 2 + 8) * 6
+(7 + 8 + (3 + 9) + 7 * 8 + 8) + 6
+(4 + 5 + 5 + 3 * 9) * 7 + 9 * 7 + 8 * 5
+8 * 5 * (8 * 6 * 2 + 4 * 3)
+2 + 2 * (6 + (4 + 5 * 7)) + (9 + (4 + 5 * 8 * 2) * 3 + 2)
+3 + 6 * ((9 + 9 * 7 * 5) + 7 * 5 * 8 * 4 + 6) * 3 + 2
+8 + ((5 * 5 + 3) + 9) + 4 + 8
+8 + (9 + (2 + 4 + 3 + 4) + (8 * 5 + 9 + 4)) * (4 * (3 * 7)) + 3 * 3
+9 + 4 + ((5 + 9) + 2) * 6 + ((3 + 9 + 7) * 3 + 2 * 6 + 9 * (7 + 9 + 3 + 3))
+6 * (8 + 5 * 3 * 8 + 3 * 2) * 5
+8 + 5 + ((7 + 2 * 3 + 7) * (9 * 5) * 3 + 2) * 3
+9 + 6 * 8 * ((4 * 5 * 4 * 8 + 8) + (9 + 9 * 7 + 6 * 5) + 6 * 6) * 2 + 3
+4 + 8 + (6 + 5 * 4 * 2 + 2 * 5) + ((2 * 9 + 8 + 7) + (4 * 5) + 6)
+((9 * 5 * 7 + 4 * 7) + (7 * 4 + 2 + 2) + 8 * 9 * 7 * 6) * (9 * (5 * 4 * 4 + 3)) + 8 * (5 + (5 + 8 + 7) * 4 * (9 + 8 + 6) * 3) * 2 * 6
+((3 + 6 + 6 + 4 + 5 * 6) + 5 * (5 * 7 + 9 * 4) + (4 + 2 * 6)) + 3 + (8 + 4 + 5 + 4 * 4 * 8) + (7 * 3 * 4)
+6 + (3 * 3 + 8 + 2) + ((6 + 7 * 3) + 9 + 7 * 3 * 4 * 4) * 6 * 6
+7 + (6 * 4 * 3 + 7 + 8 * 7) * 3 + 8
+8 * 9 * 6 + 9 * 3 * (8 * (8 * 5 + 5) + 4 * (5 + 5) + (9 + 2 + 2 * 5 + 3 + 5))
+9 + 2 * 2 + (4 * 2) + 7
+3 + 3 * (3 + 2 * 2 + 3) + (9 + 6 + (6 + 3 + 9) * 6 * 4 * (3 + 4 * 8 * 7 + 9 + 5)) + 9
+((2 * 8 + 8 * 4 * 3) + 4 + 7 + (5 * 5 + 8 + 6)) * 6 + 4 * ((4 * 3 * 8 + 2 * 9) * 4 * 8)
+(4 + 9 + (3 * 5 * 5)) + 4 + (3 * 4 + 4 + 2 + 6) + 7 * 5 + 8
+(2 * (2 + 3 + 2) + (3 * 8 + 6)) * 9 * 2 * 9 * 9 + 9
+5 * (9 + 4) * 4 + (3 + 7 + 9) + 5
+4 * 5 + (7 * 6 + 7 + 5) * (6 + 2) + 7 * 4
+3 * 6 + 3 + (6 + 7 * 2 * 4) + (9 + (7 + 8 + 7) * 6 * 9 + 6 * (6 * 8 * 8 + 5)) + 2
+5 * 2 + ((9 + 7 * 2) * (9 + 2 + 3 * 2) * 7)
+((4 + 8 + 2 + 3 + 6 * 3) * 8 + (7 * 9 * 5 + 3 * 2) * (7 * 7 * 9 * 2 * 5) * 3) + 8
+9 * 3 * (6 * 2 * 6 * 4 * (3 * 9) + 2) + 4
+2 * (6 * 9 + (9 * 2)) * 4
+9 + 7 + 7 * 7 * (7 + (9 * 9 * 2 + 4 + 9) * (3 + 4 + 2 + 9) + 6)
+4 * 6 + (3 * (2 * 5 + 4 * 3 + 4) + 6 + (5 + 9 * 7) * 9 + 3) * (3 * 3 * 7 * 7) * 8 + (5 * 6 + 4)
+4 + 7
+((7 + 5 * 8 + 6 * 3 * 9) * 3 + (5 * 9 * 3 * 2)) + (5 * 6 * 4 * 2) * 7 * 4 + 5 * 6
+(2 + 9 + 2 * 7) + 6 + 3 + 9 + 7
+((6 * 5 + 2) + 4 * 7 + 4 * (7 * 4 * 2 + 4) * 7) * 3 + 4
+5 + (2 * 3 + (9 * 8 * 9)) + 7 * (6 + 7 + 2)
+4 * 5 * 8 + 6 * ((4 * 7) * 8 * 8 + 7 * 8 + 2)
+8 + ((8 * 2 * 6) * 9 * (9 + 2 + 9 + 4 * 3 * 7) + 5) * 2 * 8 + 8
+((8 + 4 * 2 + 4) * 5 * 4 + 4 + 8 + 5) * 4 * 6 + 3 + 4 * 4
+6 + 7 * 6 + (6 + 6 + 2)
+((4 * 9 * 9 + 8) * 6 * 9 + 6) + 2 + 8 * 8 * ((4 * 9 + 6 * 7 + 5) * 4 * 7) * 7
+6 + 5 + (8 + (2 * 8 * 6 * 3) * 4) + (8 + 2) + 2
+(9 * 6) + 5 * 2 * (8 + 5 + 6 + 7) * 4
+9 + (8 * (2 * 4) + 6) * 8 * 4
+9 + 6 + (3 + 2 * 8)
+3 + 9 * 2 + 7 + 4
+((7 * 9 + 3 + 3) + 5 + (4 * 7 + 9 + 4 + 2)) * 3 + ((9 * 6 * 8 + 5 + 7) + 5 + (4 + 8) + 2 * 4) + 3 * 5
+6 * (9 + (4 * 7 + 9 * 7 * 6 + 9) + 6 + (4 + 7 + 3 * 4 * 6) + 4 + (5 + 2 * 5)) + ((8 + 7 * 3 + 6 * 4 * 7) * 3) + 5 + 9
+((7 + 5) + 9 + 8 * 5) * 6 + 3 * 7 + 2 * 3
+(9 + (5 + 8 * 9) * 9) + 3 + 6
+9 + 7 * 5 * 8 * (2 + 4)
+6 + 3 * 7 + (3 * 5 + 8 * 7 * (4 * 8 * 5 + 9 * 6 * 4)) * 3
+5 * (4 * 2 * 5 + 6 * 7 * (3 * 9 * 9 + 4 + 2)) + 9
+(5 * 7 + (8 * 4 * 4 * 4 + 5) + (9 + 9) * 5 * (3 + 6 + 7 * 9 + 6)) * 4 + 6 + 4 + ((7 * 4 + 7 + 2 + 7 + 2) * 5)
+(4 * 3 + 5) + 2
+(4 * 4 * (9 * 7)) + (4 * 5 * (3 + 9 * 3 * 2)) * (5 * 7 * 4 * 6)
+2 + 5 * (7 + 2 + 8 + (2 * 9) + 7 + 7) + 2 + 6
+((9 * 5 * 3 + 7 + 7 * 8) + (6 * 3 + 4 * 8) + 4 * 9 + 9) + 9
+8 + 2 * (9 + (7 * 7 * 3) + 2) + (6 + 5 * (3 + 6 * 9) * 6 + 3)
+((4 + 8 * 6 * 9 * 2 + 3) + 8 * (7 * 7 * 8 * 6) + 9) * (2 + 6 * 9) + 6 + 4
+6 * 5 + 8 * 7 * (3 + 4 * 7)
+7 * 5 * (5 * 7 + (2 * 7 * 6) + (6 * 3) * 9 + (4 * 7 * 6 + 7 * 7 * 3))
+8 + 7 * 3 + (4 + 6 * (4 * 4 + 9 * 7) * 6 + 8 * 2) * 8 * (8 * 3 + 3 + 6)
+2 + 6 + ((6 + 2 * 3 + 2 + 2 + 6) + 3 + 5 + 7)
+((9 * 7) + 8 * (9 * 3 * 9 + 8) * 2 + 7 * (6 + 7 + 4 + 6 * 3)) + 7 * 4 + 7
+5 + ((8 + 6) * 7 * 9 + (4 * 5 + 5) * (5 + 3) * 7) + 3
+4 + ((5 + 4 * 5) + 2 * 6 + 5)
+6 + 6 * 8 + (3 * 8 * 2 * (5 + 3)) + 6 + ((3 * 7) + 9 + 7 + 7 + 6 * 7)
+(2 * (4 * 7) + 6 + 8 * 3 + 7) + 8 * 6 * (3 + (3 + 4) * 2 * 3 * (4 * 5 * 2 * 2 * 6)) * 8 * 4
+6 + (8 * 3 + (3 + 9 * 6)) + 2 * 4
+3 * (2 * 9 * 3 + 3) * 5 * 6
+6 * 5 * 3 * 3 * (6 + 7 + 9 + 8)
+9 + 2 * 8 * 6 + ((9 * 9) + (3 * 4 + 4 + 4 * 9 * 7) + 5 + 4 + 9 + 9)
+3 + 9 * 5 * 8 * 5
+5 + 3 * 7 + 9
+9 * ((4 + 4 * 6 + 5) + 3) * (4 + 3)
+(3 * 6 * (8 * 6 * 5) + 2 * 3 + 4) + 6 + 8
+6 + (4 * 8) * 3 + 5 + 2
+2 + (2 * (7 + 6) * (5 + 3 + 2) * 2 + (7 * 9)) * ((5 + 9 + 2 * 8 + 8) + 9 + 8) + 9 + 6
+((5 * 8 * 4) * 6) + 4 * 4
+6 * 2 * (3 + 4 + 3) * (5 * 4 * 7) * (2 + 4 * 2 + 8)
+6 + 9 * (2 * 7 + (4 * 5 + 7 * 6 + 7 + 8) + 4 + 5)
+((4 + 6 * 2 * 4) + 2 + 4 * 3) * 9 * 5 * 9
+6 + (3 + (5 + 4 * 2 * 3) + 6) + ((8 + 4 * 8 * 5 * 4 * 4) + 5 * (6 * 6 * 9 * 9) * 3 + 3)
+7 * 8 * (7 + 8 * 2 + 6) * 9
+5 + 3 + 4
+4 + (3 * 6)
+9 * (2 * 6 * 2 + 4 * 5 + (2 + 4 + 6 + 3 * 4 * 5)) * 4 * (8 * 7 * 6)
+6 * (9 * 5 * 9 * 4 + 4)
+(8 * 7 + 8 * 9 + 2) + 4
+6 + (7 * 6 + 8 + 2 * 3 * 8) * 8 + 4 * 2
+((4 * 8 * 7 + 8) * 9) + (9 + 5) + 4 + 2
+4 + 9 + (5 + 3) + 4 * (9 * (4 * 7 * 5 * 2) * 8) * 3
+5 + 3 * 5 + 6 * 7 + (2 + 7 + (7 + 7 + 9 + 2 * 4 * 6) * 6 * 8 * 8)
+(6 * 4 * 8) * 9 + 7 + 2
+3 * (5 + 5 + 2 + 6 + 3) + 5
+((2 + 6) + 3) * 7 + 3 * 8 + 2 * (7 + 4 * 4)
+4 * 6 * 8 + (7 * 2 * (5 * 7) * 3 * (2 * 4 + 6 * 4 * 2)) + 2 + 9
+7 + (9 * 4 * 5 * 8) * (4 * 2 + 7 * 2 * 3 * 7) * 3 * 2 * 9
+4 + 6 * 8 * 4 * (2 * 8) + 4
+4 * (8 + (9 + 3) * 4) + 2
+(6 + 7 * 5 + (8 * 4 * 5 + 7 + 8 * 8) + 9) + (4 + (6 * 8 * 6 * 3 + 9) + 4 + 2) + ((9 + 4 + 8 * 7 * 9 + 2) * 2 + 2 * 2 * (2 * 6 + 9)) + 6
+8 + ((5 * 5 + 3 + 2 + 5 * 6) * 6 * (2 + 9 + 8) + 5 + (7 + 6 + 4) + 9)
+(4 * 5 * 9 + 8 + 8 * 5) * 2 * (7 * 9 * 3 + 3) + (2 + 5 * 5 * 3 + 4) + 5 + 7
+(2 + 8 + (5 + 7 + 2 * 9)) * ((8 + 6 + 8 * 2 * 3 + 4) * 3) * 2 * 9
+((2 + 7 + 6) + 2 * (3 + 6 * 6 * 5 * 2 * 7) * 3 + 8) + 3 + 7 * 6
+5 * 5 + 7 + 3 + 6 * 2
+4 + 9 * (9 + 6 + 6) * 7 * 9 * 8
+((8 + 5 * 8 * 4) * 5) * (8 * 7 * (4 + 5 + 4 + 3 * 3))
+(9 * (8 * 9 + 9 * 6 + 5 * 8) + 3 * 9 * (5 + 6 + 6 * 4 * 4 * 6)) + 4 * 6 + 8
+6 + (9 * 8 * (8 * 3 * 3 * 7))
+(7 + 7 + 6 + 8 * 3 + 9) * 4 + 9
+7 + 2 + 3 + (8 + 5 + (7 * 7 + 8) * 9 + 7) * (2 + 5 * (4 * 8 + 2 * 5 * 7) * 3 * 9)
+((3 + 7 + 4 + 9) + 5 + 6 * 3 + 3 * 8) * 2 * ((9 + 5 * 9 * 5) * 3 + (3 * 5 * 7 * 2)) * 9 * 5
+6 + 4 * 9 + (3 + (5 * 3 + 5) * (3 * 8 * 2 * 5)) + (4 + 9 * 4 * 8 * 7 * 4) + 2
+9 + (6 * 8 * 4 * (7 + 4 * 5 * 3 + 5 * 5) + (2 * 7 * 7 * 8))
+(8 + (9 + 8 * 6 + 2) * 7 * (6 + 2 * 6 + 6 + 4 + 7) * 9) * 5 + 3
+4 * 4 * (2 + 8 + (4 + 5 * 4)) * (6 * (2 * 3 + 7) * 7 + 9 + 8) + 3 * 3
+4 * ((9 + 7) * (7 + 2 + 5 + 2 * 4 * 2) * (3 * 7 * 6 + 5 + 9 + 2) * (6 + 9 * 2 * 5 * 8 + 6) + 5 + 8)
+(6 * 5 + 9 + 6) + 2
+2 + 2 * 5 * (3 * 9 + 2 * (6 * 5)) * 8 + (7 + 6)
+2 + (2 + 5 * 9 + (5 + 3 + 8 * 2 + 2) * 4) * (8 * 2 * 2 + 3 + 5 + 8) * 4 + 3
+4 * 9 + (7 * 6 + 2 * (6 + 2 + 9) + 2 * 3)
+(5 * 2) * (4 + (9 * 9 + 9) * 9 + 6 + 6) * (6 * 8 * 7 + 7) + 9 + 3 + 2
+(4 + 2 * 2 * 8 + (3 + 7) * 7) * 8 * 9
+(3 + (8 * 2 + 6) + 5) * 9
+2 + 2 * 4 + (7 + 3 * 9) * 5 * 6
+7 + (4 + 8 * (3 * 7 * 3 + 9) * 9) + 2 * (4 + 8) + 5
+2 * 5 + (4 * 9) * 7 + 5
+7 * 3 * (8 + 2 * (9 * 6) * 8 + 6 * 9) * 9
+9 * (9 + 6 * 2 * (9 + 4 + 8) + 4 * (5 * 8 * 4 + 6 * 6 * 9))
+3 + 7 + ((9 * 6 + 2 * 9 + 6) + 3 + 2)
+(3 + (7 + 4 * 3 + 6 + 7) + (5 * 3) * 8 + 7 + 5) * 2
+(8 * 5) * 8 * 3
+9 * 2 + 9 * 9 * ((3 + 8 + 6 + 5) + 5 + 2 * 2) * 2
+(5 * 4 + (7 * 8 * 2 * 5 * 5 + 2) * 3) * 2 * 7 * (7 * (4 * 8 + 8 + 4 * 6))
+7 + 3 * (8 + 7 + 2 + 4 + (2 * 7 + 3 + 9) * 5)
+4 + 5 + 4 + 5
+8 + 6 * (3 + 8 * 2 * 7 * 9 + 4) + 8
+(9 * 3 * 9 * (3 + 2 + 7 + 5)) + 4
+4 + 4 + (4 * 4) + 3
+6 + 3 * (3 + 3) + 7 * 2 + (8 * 8 + 7 + 8 + 4 * 4)
+4 + 9 * 6 + (2 * 9) * 3 + 6
+4 + 8 + 8 + 2 * ((2 * 7 * 7 + 8 + 4 * 3) * 3 + 8 * 9 * 4)
+(2 * 6 + 7 + (2 * 4 * 5 * 2 * 6) + 7 + (6 * 3 + 3 + 7 * 8)) * 8 + 3 * 8
+3 * 7 * 3 * 5
+((4 * 9 * 5 + 3 + 4) * 4) * 7 + 3 + 5
+9 * (2 + 5) + 2
+3 * 3 * (8 * 7 + (2 * 9 + 4 + 2 * 9 * 6) + 9) * 2 + 5 + (5 * 8)
+7 + ((3 + 2) * 5 + 6 * 3 + 4 + 5) + (4 * 5 * 9 * 7) + 4
+4 + 4 + 7 + 7 * (3 * 9 + 2 + 4 + 2 * 6) + (6 + 8 * 6 + 9)
+4 * 2 * (4 * 3 * (7 + 2 * 6)) * (6 * (2 + 5 + 7) + 8) + 2
+(3 + 7) * (9 * 7 + 8 + 2) * (8 * 9 + (7 * 7 + 6 * 2 * 6) + (7 + 7 * 6)) + 9 * 7 + 2
+5 + 9 * ((9 * 2 + 5 + 8) + 7 * 7 + 5) + ((3 + 2 * 8 + 8 * 6 + 8) + 4 * 2 * 3 + 9) + (3 * 2 + (6 * 3 + 3 + 6 * 5 * 7) + (2 * 3 * 5 * 9))
+(8 * 9 + 9 + 3 + 3 * 6) * 8 * 8 * 4
+(3 + 4 + 6) + 8 + 4
+(4 + 2 + (6 + 2 + 4)) + 7 + 2
+(3 * 3 + 5 + 5 * 2) + 9 * ((5 * 9) + (9 + 7 + 2 * 9 + 4 * 9) + 3) * ((3 * 2 + 3 * 7 * 6) * (7 * 3 * 4 * 6 + 3)) + 6
+2 * (2 + 9 * 7) + 2 * 8 * 4 * 7
+2 + 6 * (2 * 9 + (4 + 2 + 4 * 5 + 6 + 6) + (5 * 5 * 8) + (8 + 3 + 7 * 8)) * 5 + 9
+(8 + 3 + (6 + 7 + 4 * 9 * 9 + 3)) * 8 * 2 + (5 * 6 + 6 + 6 * 5 + 4)
+(5 * 5 + 2 * 8 * 5) + (8 * 5 * (9 * 3 * 8 * 9)) * 6 + 5 + 4 + 4
+8 + 4 + (2 * 2 * (8 + 2 * 8 + 2 * 9)) + 6 + 3
+3 * 9 * (8 + (7 + 3 + 4 + 5 * 7) + (7 * 5 + 9)) * ((6 * 7 * 6 + 8 + 5) * 6 + (7 + 4) * 5 + (6 + 6 + 3 + 8 + 5) + 2) + ((2 * 7 + 9 * 5 + 3) * (8 * 6 * 2 * 3) + 6 * 9 + 4 + 5) + (6 * 5)
+4 + 4 * 2 + (9 + 3 * (5 * 6 * 4 * 5 + 4))
+6 + 2 * 6 + 7 + 9 * (8 * 4)
+(3 + (5 + 4 * 4 + 8 + 4 + 5) + 8 + 8 + 3 * 8) + 9
+3 * (7 + 4 * (7 + 2 + 6)) * 5
+6 * (5 * 3 * (7 * 3 * 7 + 9 * 5 * 8))
+4 + 7 * 6 + 5 + 6 * 7
+(7 + 9 * (4 * 3 + 2 + 3 * 4 * 6) * 2) * 6 * (5 + 8)
+3 + ((9 * 6 + 6 * 4) + (9 * 9 + 9 + 7 * 3) + 3 * 8) * 7
+(9 * 2 + 2) * (3 + 9 * 3 * 5 * 7)
+5 + 2 + 9 + (6 * (6 + 4 * 4 + 9) + (8 * 4 + 5 * 3 * 9)) + 9 * 5
+8 + (4 + 9 * (7 + 3 * 6 * 5 + 9 + 7) + (3 * 6)) + 5 * 6 + 6
+(7 * (8 + 3 * 3 + 7)) * 9 * (6 + 9) + 3
+5 * ((6 + 7 + 9 + 3 * 2 + 3) + (3 + 5 * 5 + 3 + 9)) + 3 * 7 + 6 + (7 + 4 + (3 * 3) * 5)
+8 + 6 + ((9 + 8 + 3 * 6 * 9) * 3) * 8 + 7 * 9
+7 + (8 + 3 * 6 * 8 * 8 * 3) * 5 * ((3 * 6 * 2 * 7 * 7 + 4) * 5)
+(2 + 2 * (3 + 6) * (8 + 5) + (8 * 6 + 7) * 9) + 6 + 8 * 9
+7 + 7 + (4 + 2 + 4 + 6 * 5 + (8 * 6)) * 9
+7 * 3 + 7 + ((9 + 7) + 6 * (5 + 9 * 8 + 6 + 5 * 4) * 8 * 3 + 3)
+(2 + (2 + 9 + 2)) + 2 + 8
+2 + 2 * (5 * (8 * 4 * 7 + 3 * 5) + 6) * ((9 + 3 * 2 + 5 + 8) * 2 * 9 + 2) * (3 + 9 + 4 * 5)
+7 * 8 * 2 * 8 * 9 + (4 + (5 * 6 * 8 * 9 + 7))
+6 + 2 + 7 * (6 + 7 + 6 * 8 + 9) * 3
+6 + 6 * 7 * (4 * 9 * 9 + 7 + 4 + 9) + 9
+(9 * 9 + 6 * 6 + 3) * 3 * 2 + (3 * 8 + 8 + 4)
+9 + 6 + (9 + 3 + (7 + 5 + 2 + 3))
+5 * 4 + (2 + 2)
+((7 + 7 * 6 + 2) + 7) + 8 * 7
+6 + (5 * 2) * 9 + 8 + 7 + 8
+9 * 8 + 3 * (4 + 8 + 8 + 5 + 9)
+4 * (2 * 8 + 8 + (5 + 5 * 3 * 5 + 2) + 9 * (8 * 6 + 2 + 2)) + 9 * (6 + 6 * 3 + 8) * 4 + 7
+(3 * 6 + (4 * 9 * 2 * 4 * 8)) + (3 * 5 + 7) + ((9 * 5 + 5 * 2) + 9 + 8 * 7 + 3)
+5 + (3 + 9 + 6 + 2 + (6 + 4 * 2))
+(9 * 5 * (9 * 9) + 8 * 7) + 2 * 7 * 3 + 3
+(9 * 5 + 6 * 7 + 4) * ((3 * 2 * 9 * 4 + 4 + 6) + 2 * 4 + 4 + 9 * 7) * 2 + (8 + 8 * 6 * 8)
+6 + ((5 * 9) * 4 * 5 + (4 * 3 * 7) * (5 + 3 * 3 * 8 + 4 * 4)) + (5 + (6 + 3) * 2 + 8 * 2 + 3) + 3 * 3
+8 + (3 * 8 + 5 + 6 + (3 + 4) + 8) * 2
+9 + 2
+(8 + 2) * 2 * 2 + ((9 * 9 * 4 * 5 * 5 * 3) * 2) + (4 * 3 * 8 + 9 + (8 * 3 * 7 + 4 * 8 * 5))
+6 * 7 + (8 * 5 * 8 * 7 + 7) * 9 + 3 * 7
+3 * 5 * 7 + 8
+(3 + 2 + (8 + 9 * 9 + 6 * 8 + 6) * 3 * 6 + 6) + 4
+3 + 8 + 4 * (4 + 7) * (5 + (3 + 9 + 6) * 7)
+((4 + 5 * 8 * 5) * 8 * 5) * (2 * 4 * 9 * 4) * 6
+(8 + 3 * 5) * 2 + 2 * 4 * 8 * 6
+8 * 7 * (4 * 7 + (4 * 3 * 4 + 3 * 7) + 2 * (6 * 6 + 6 + 4 + 7 + 2))
+6 + 9 * 5 + 4
+5 * 6 * 8 * ((6 + 9 * 2 * 8 + 5 + 8) + 3 + 6)
+4 * ((4 + 7 * 9 + 9 + 3) * (2 * 4) * 6 + (5 + 9 + 7) + 5) * (8 + 2 + 8 * 5 + (6 + 7 * 7 * 6)) * 2 + (7 * 8)
+(7 * 3 + 4 * (9 + 2 + 6 + 6 * 4 + 2) * 4) * 6 * 2 * 2
+3 * (4 * 8 * 3 + 8 * 6 * 2)
+(3 * 3 + 8 * 4 * 4 + (6 + 3)) * 2 * 7 + 5 + 2 * 4
+9 * 3 * (4 * 7 * 9 * (2 * 4 + 9 * 2) * 2) * 7
+5 + (4 * (6 + 5 * 9 + 6 * 7 * 3) + (7 + 2 + 2 * 9 + 2 + 2) * 3) * 4 * 6 + 2
+7 * (6 * 6 * 7 * 2 + 8 + 8) + 7 + 8 + 7 * (9 + 3 + 4 * 4 + 4 * 8)
+8 + 2 * (4 + (2 * 3 * 8 * 4 * 3))
+6 * (6 * 4 + (5 * 7 * 8 * 2 + 4 * 9) * 2) * 9 + 3 + (3 + 7 * 5 + 3)
+3 * 7 * 5
+7 + (2 * 5 + 5)
+6 * (5 * 9 + 5) * (8 + 7) * ((8 * 8 + 4 + 5) * (2 * 2 * 7 + 4 + 2) + 5) * 3 * 3
+4 * 2 * 2 + ((4 * 7 * 8 + 9 + 2) + 6 * 4 + 3) * (4 + 3 + 3 * 9 * (8 + 6 * 8 + 3 + 9) * 3) * 8
+8 * 9 * 8 + (9 * 7 * 2 + 7) + 4 * (6 + (8 + 3 + 5) * 5 * 3 + 6 * 9)
+((4 + 4 + 5 * 8 + 9 * 4) * 8 * 9 + 6 * 9 * 8) + 4 + ((9 * 2 * 7 + 5 + 3 + 6) + 3 * 4) * 8
+4 * (3 + 4 + 8 * 6 + 8 * 7) + 3 * 9 * 8 * 8
+(4 + 8) + ((7 + 3 * 9) * 5 * 8 * 4)
+3 * 9 + ((5 + 4 + 8 + 9) + 5 + 5 + 8 + 5)
+8 * (9 * 3 * (9 * 8 + 6 + 3) * 8 + 6)
+(5 + (3 * 7 + 6 + 9 * 7) + 8) + 2 * 3 * 7 + 2
+8 + 3 + 8 + ((3 + 6 + 8 + 2) + (4 * 9 * 7 + 5) + 6 * 2)
+(7 + 5 + 6 + (6 * 9 + 8 + 8 + 2 + 5) * 4 * (9 * 4 * 8)) + (8 + 5 * 3 * (2 + 8) + 7) + 8
+2 + (3 + (6 + 9 + 9 * 5 + 2) + 9)
+((4 * 9 + 4 + 7) + 6) * 5
+2 * 3 + (7 + 5 + 9 + (9 + 9 + 8 + 5 * 8 * 7))
+7 * (4 + 4 * 7) * 4 + 2
+3 * (4 * 6) * 2 + 4
+2 * ((5 * 8 * 8 * 4) + 8 * 6 * 3 * 3)
+6 + (2 * (8 + 4) * 3 + 8 * 4) + ((3 * 9 + 6 * 4 * 8 + 3) + 9 * 9 + 3 + 3 + 2) * 4 + 6
+3 + 6 * 6 + (6 + 9 + 7 + 2) + 9
+(5 * 5 * (2 + 2 + 9 + 8)) + 7
+(5 * 7 * 6 + 9) * (6 + 4 + 9 + 6 * (8 * 2 * 2 + 5 * 9) + 6)
+9 * 7 + (2 * 2 * 8 + 9 * 7 * (8 + 4 * 8 + 4)) + (8 + 6 + 6)
+6 + ((3 + 9 * 4 + 7) * 3 * 8 + 4 + (3 + 3 * 6 + 6 + 8 * 5)) * 8 * 8 * 3 + 3
+5 + 3 + 6 + (2 + 3 * 9 + 2 * 8 * 8) + (6 * 6 * 5 * 6 + 6)
+(6 + 2 * 8 * 6 * 7) * 6 + 6 + 6
+(3 + (6 + 9 + 3 + 3 * 4) * 8 + 6 + 7 * 8) + (2 + 8 + 9 * 9 * 7) + 4
+2 + 7 + 2 + 3 + ((4 * 5 + 4 * 3 * 3 + 7) * 4 + 8 + 9 + (2 + 7 + 2 * 5 + 3) + 9) * 6
+(7 * (6 * 5 + 2 * 6 * 2)) + 9 + 6 + ((8 + 4) * 5 * 3 + 5 * 8) * ((5 * 5) + (8 + 4 * 5) * 8 + 4 + 2)
+((4 * 6 + 2 * 5 + 8) * 9 * 3) + 3 + 5 + 3
+5 * 5 + (2 * 9 * 9 * 6) + 3 * 8
+3 + 7 * 2
+9 * (5 + 6 + 2 + (8 * 8 + 9 + 8 + 4 * 6))
+(9 + 2 * 7 * 2 + 5) + (4 + 6 * 3) + ((6 * 4 + 4 * 2 + 5) + 8 + 6 * 6)
+3 + (7 * (2 + 5 * 5 * 4 * 4 + 7) * 4 * 4)
+8 + 3 * ((3 * 7 * 3 + 4 * 5) * (6 + 8 + 9 * 7 + 6) * 9 + 5 * (5 + 4 + 4 + 4))

2020/src/main/resources/day19.txt

@@ -0,0 +1,536 @@
+107: 18 | 47
+116: 1 18 | 111 47
+21: 45 47 | 110 18
+20: 2 47 | 76 18
+44: 47 47 | 18 107
+2: 47 18 | 107 47
+113: 51 47 | 35 18
+80: 18 22 | 47 44
+110: 18 18 | 47 107
+1: 22 18 | 112 47
+77: 47 7 | 18 113
+16: 121 47 | 2 18
+66: 91 18 | 58 47
+86: 12 18 | 78 47
+72: 18 76 | 47 121
+46: 47 68 | 18 82
+131: 66 18 | 75 47
+108: 84 18 | 24 47
+27: 22 47 | 110 18
+53: 108 18 | 122 47
+90: 77 47 | 37 18
+6: 18 29 | 47 52
+10: 76 18 | 44 47
+43: 47 39 | 18 130
+106: 18 112 | 47 110
+89: 97 47 | 51 18
+84: 112 18
+91: 74 47 | 110 18
+114: 18 47 | 107 18
+105: 26 18 | 118 47
+18: "b"
+19: 2 47 | 22 18
+15: 34 47 | 2 18
+111: 110 47 | 22 18
+94: 47 95 | 18 57
+34: 107 107
+60: 47 114 | 18 121
+62: 44 47 | 45 18
+50: 38 47 | 103 18
+61: 18 44 | 47 110
+87: 112 107
+8: 42
+31: 18 49 | 47 25
+57: 18 20 | 47 60
+103: 18 67 | 47 40
+39: 18 45 | 47 22
+128: 112 18 | 13 47
+5: 45 47 | 44 18
+13: 18 18
+3: 47 10 | 18 80
+11: 42 31
+124: 22 18
+88: 18 18 | 47 18
+54: 32 18 | 129 47
+63: 81 18 | 86 47
+49: 18 132 | 47 105
+102: 10 18 | 120 47
+93: 18 44 | 47 34
+65: 107 2
+132: 83 47 | 14 18
+125: 18 43 | 47 71
+109: 47 22 | 18 76
+117: 18 112 | 47 22
+59: 47 22 | 18 13
+75: 18 109 | 47 27
+4: 47 90 | 18 69
+48: 18 65 | 47 115
+24: 18 2 | 47 44
+42: 47 50 | 18 4
+96: 106 47 | 16 18
+101: 111 47 | 91 18
+58: 47 76 | 18 73
+79: 47 73 | 18 22
+12: 47 34 | 18 88
+25: 33 47 | 55 18
+130: 18 114 | 47 44
+83: 126 18 | 102 47
+45: 47 18
+9: 41 18 | 62 47
+78: 112 18 | 45 47
+14: 3 47 | 85 18
+97: 47 45 | 18 22
+22: 18 47
+41: 18 22 | 47 112
+112: 18 47 | 18 18
+68: 21 18 | 19 47
+121: 47 47 | 18 18
+119: 22 47
+129: 47 5 | 18 39
+30: 73 18 | 2 47
+98: 34 18 | 45 47
+40: 18 70 | 47 9
+7: 64 47 | 79 18
+115: 121 47 | 44 18
+32: 19 47 | 30 18
+73: 18 47 | 47 18
+35: 18 76 | 47 45
+95: 93 18 | 72 47
+52: 28 47 | 124 18
+126: 59 18 | 92 47
+26: 104 18 | 89 47
+81: 47 98 | 18 127
+0: 8 11
+64: 112 47
+71: 47 119 | 18 117
+74: 47 47
+82: 47 120 | 18 17
+56: 74 47 | 88 18
+123: 88 47 | 76 18
+33: 6 18 | 63 47
+104: 80 18 | 128 47
+99: 98 18 | 23 47
+38: 94 18 | 53 47
+36: 47 110 | 18 74
+37: 47 48 | 18 101
+70: 61 47 | 87 18
+55: 47 54 | 18 131
+23: 2 47 | 112 18
+122: 10 47 | 64 18
+120: 88 18 | 112 47
+28: 18 112 | 47 73
+51: 47 74 | 18 110
+17: 47 88 | 18 22
+127: 18 73 | 47 45
+69: 125 18 | 46 47
+92: 2 47 | 114 18
+29: 117 18 | 56 47
+67: 18 96 | 47 116
+85: 18 36 | 47 15
+100: 18 123 | 47 12
+47: "a"
+118: 100 47 | 99 18
+76: 47 47 | 47 18
+
+bbbbbbbbbaaaabbaababbabbaaabbbabbbbaaabb
+babaabbaabbbbaababbaabbabaababba
+baabbaaabbabbbbaaabababb
+bbbbababbaabbbabbabaaaaaaabbbbbbabbabbbaabbbbbbbbbaaaaab
+bbbbbabbbbbbaaabbaaaaaba
+baabbabbbaabbbabbaabbabbababaaab
+bbabbbbaabbabaaababbbbbbbbbabaab
+aaababbaabbaaabbbbbbbabbbaaaabbaabbabbabaababbaa
+aabbbabbaaaaaaabbbabbaba
+baabaaaabbbababbbbaabbbb
+bbbbabababbbbabbbbbbbbba
+babbaababbbbababaabaababbbabbbbbaabaaabb
+baabbbabaabbabbbaaaaabba
+baabbabbbbaabbbabbbaaabb
+aaaaabbaababaabaabbabbbbbabbabaabbaaabbb
+babbaabaaabbbbbbbbbbbabbaabbaaabbaaaaabbabbaabaabaaabbbaaabaaabb
+aaabaaabbaaaaabbabaaaaababbabaaababbaabaabbaaaabaaaabaaaaaaabbaaababbbbb
+baaababbbaabaaaaaaaaaaaabbababaababaaaaabaaabaaa
+abaaaaabbbaababababaaaba
+abbaabbabaaabbabaaaaaabaababbabbbbbbabbaabaabbbb
+baabbabaaaaabbabbaaaaaabaababaab
+abbaabbabbaabaaaabbaaabbabbaaababaaaaaaa
+abaaaaabbbbaabbabbbbbbaaaaaaababbbbbbaaa
+aabbaaabaaaaaabababaabab
+bbbabbaaaaabaaaaaabbbbaa
+abbaaababbaaaabbaabaaabbbaaaabbbbbbbaaaaabbbbabaabaabbab
+aaaaaaaaaababbabbbabbaba
+abbaaaaabbbabbbaabbaaabbabbbbaabbabbabbbabaababbbbabaaba
+babaaaaabaabbaaabbaabaaababababa
+bababaabbaaaabbabbbabbbabaabbaaaabbaaababbbbbbaaaaababaa
+aabaabbababbbabaaaaaaaabababaaaababbabaabbaaaaabbbbbbaab
+baaabbbbaaabbaabaaaaabaaababbaabaaababbabaababbb
+abaabbbaaabbabbabaaababbbbabbaaaabaaaabb
+abbaababbaaaaabbbbaaabbb
+aabbabbabbaaaaaabbbaaabb
+baabbbabbabbaababbabbbbabaabbbabbbbabbbaabbabbaababbbbbaabbababbaababaab
+abbaabaabaaabbbbbaaabbabababbabbbaabbabbaaabbaaababbbababbbbbaaa
+aabbbaabbbbababbbabaabaa
+baabbaaaabbbaababaabbabbabbbbbaabababaaabaabbbbaaababbbb
+abbabababbbbbabbababbbaaaaaaabbbaabababb
+baaabbabbbbaababbbaaaabb
+aabaaaaaaaaaaabbbabbbabbaaabbbab
+abbaabbababbbbaabaaaabbaababbabbaaabbbbabbbaaabbbbaaaabb
+baaabbabbbaabaabbbabbaba
+abbbbbaaabababbbbbbabbbb
+aaabbabbbbaabbbabbaaabbb
+babbbbaaabaaabbaabaaaaabbabbaaab
+aaabbabaabbaababaabbbbbbbabaaaba
+baaaaabbababbbbabbbbabbbababaaaa
+abbaaaabaabbbaabbabbbbab
+bbbaabbaabaaaaaaababbbbaabbaaaaabbaaabbabbabbbaa
+baabbbabaabaabbaababbabbbbaaaaaaaabbbaabbbabbbaa
+babaabbabbbbaabaabababbbaabaababbbbaabbb
+aabbbabbbaaaaaababbaaaaaaabbaaabbabbabbaaabbaaba
+aaabababababbbabbbaabaabaaababbaabbbaabbbbaaaaba
+aaabaaababbaababbbbabbab
+baaabbabbaabaaabaaaababbabbbabba
+abbbabaaaabbbaaaabaabbabbbaabbbbaaabaabb
+abbbbabbabbaababbbbbbbaabaaabbbbabaabababbbaaaabaabbaaba
+baabbababbbabaaaaabbbaab
+aaaabbaabbaabbbbaabbaaaabbabbabaabaaababbaabaabababbaabbbabbbaabaabbbabbbabaaabb
+abaaaaabbabbaaaabbabbbaa
+baaabbbbababbbaaaababbabbabbaababbabbbabbbbbaaaa
+aaaababbabaaaaabbbaabaabbababbbbaabbaaabbbbaaabbbabbbaaaababbaba
+abbaaabbbbbbaaabaaaaaababbbbbaaa
+aaaaabbababbaabaabaaaaaababbbaabaaaabbaa
+bababaabbbbbaaababbaaaaaaabbbbabaaaaabbbaabbbaaa
+bbaabbaaaabaaabbaabbaaaabbabaaaabaabbbab
+aabbaaabbaabaaaaaaaababbbabaabbaaaababbb
+abbbaabaabbaabbbaaaababa
+abbaaabbaabaaaabaababbbb
+baabababbbbaaabaaabbabababbbabba
+abaaabbaaaabbabaabbaaabbaaaaaaaaabbbaababaababbaaabaaaaaabbbabaa
+abbbbbabaabbaaabaaaaaabb
+abbaabbaabbbbaabbbaabaababbbbbaaababbbbb
+aaabbababaaabbabbbaaabbb
+baaababaababaabbbbbaabaa
+bbbaababbbaaabbaaaaabbabbabbbbab
+bbaabaaaaaababbabbaaaaab
+aaabaaabbabbabbabbaaaaba
+babbabababbbbabbaabbbaba
+ababaabbbaabbaababbaabababbbabbbabbbbaabbababaaababbbabbbbbabbbb
+abbbbabbaababbababbbbbaaabababbbaabaaababbbaaabb
+babaabbbababaabaabaaabbbbaabbbaa
+bbbbabbbbbababaabbbbaaabbaabababbbbbabaabaaaaaaa
+aabbabaaaaabaaabaaaaabab
+abababaaabbabaaabbaaabbababbbbaaaaaababbbabbbaaa
+abbaaaaabbabbbbaaabaabbabbaabaababbaaabaaababaaa
+aabbbabbababaabbababaabbaaabbbab
+baaaaabbbbbbbbaaabbbbbabaabaababaaaabaab
+abaaaaaaaaabbababbabababaabbbabbbbaabbababbbaaab
+baabaaaaabbaaaabbbbabaaabbababababbbbbba
+baabaaababababaaaabbabaaaabaabababaaaabb
+bbaaabbaaaabaaababbbbabbaababaaa
+babaabbaabbbbaabbbaaabbabbaabbbbbabbbaaa
+bbaaaaaaabbaaaaaababbaaaababbbabbbbaaaabbaabababababbabbbbbbaabbaaababbbbbbbbbab
+aabaababbabbaaaaabaaaaabbababbaa
+aaabbaabaabaabaabbbaababaabaabaabbaabaabbaaabbaa
+abaaabbabbbabbaabbbbbabbabaababbababbaaa
+bbabaaaaaababababbababba
+aaabbabbbabbbbbbabbaabbbbbbaababbaabaaabababbbbbabbabbaa
+aabbbbabbabbabaabababbaa
+aabaaabaaaabaaaabbabbbbaaaabbbbb
+aaaabbabbbabbbbbbaaababaaaaabbabaaaaabab
+baabbbabaaabbabbbbababba
+bbbabbbaabbaabaabbabababbbbababbabaaabbababbabbbabbbaaaabbaaababbaababaa
+abbaabbbbaaabbabbaaaaaaa
+aabaaabaaaaaaaaaaaaaaabb
+babbaaaabbabaaaaaaaaabbaabbbbaabbbabbbbbbbbaaaaa
+aabbaabbbaaaaabbabbbbbba
+baaaaabbaaabaaaaabaabbaa
+bbaabaabbaabbbabbabbbaabbbabbbaababaabab
+aaabbabababaabbabaaababaaaabbabbbbabbaabbabbbbba
+bbaaabbabaaababbabaaaaaabaabbbaa
+bbbbbabbabbbbbabbbbababa
+abaabbbabaabbabababaabaa
+babbabaaaaaababbbaaaaabbababbabbbbbbbabbbbbbabaa
+aaaababbabbbbbaabbbbaaabbaaabbbbaabbbbbababbaabababbbaaa
+babaaaaaabbbabbbaabaabbabaaabbbbbabababbbaabbbaabbaabbaa
+ababbaabbbbbbabbbabaaabbabaabaabbababbbbabbbbaab
+abaaaaaaaaaaaabaabbbbaabbababbbbbaaabbaa
+bbbaabbabbbabbaaaaabbabbbaaaabbaaabaabbb
+aaaaaaabaaabaaabaabbaaabbbabbbabaaaabaaababbbaaa
+aabbbbababbaaababababaabaababbba
+bbabbbbbbabaabbbbabbababaaaaabaabbaaabaabbbabbabababbaaa
+babaabbaabbabbabbabbabaaabbabaab
+bbbabbbaabbaaabbaabaaabaaababbaa
+abbbabbbababababbaaabbab
+abbaaaaababbababaaaaaabaaabaaabb
+aaaaaabaabbaaabaaabaabbabbabbaab
+aabababaaabaaababaabaabbaababaabbaabaaba
+bbababaabaabababaabaaaabbaaabaab
+aabbbbabbaaabababbabaabb
+bbbbbbaaaabbbbabbabaaaababbbbbba
+ababbbbabaabaaaaababbbbaabbaaaabbbabbaaa
+abbaaabbaabbaabbaaaababbbaabaabbaabbbbbabababaaabbaaababbbabaaab
+aaaaaaabbaaaaabbabaabaabbbbbbbabbbbbaaaabbbabbbb
+babbabbaaaaaaaaabbbaaabb
+aaabaaaaaaaaaabaabbabaaabaaababbbbbabaaaabbbaaba
+aabbaaabbaabbabbbbabbaaa
+aabbbaabaabbbbbaabbaaababbaabbbabbbabbbb
+bbbabbbabbababababababbbabbababb
+aaaaaaabaabbabaaababbbbb
+bbabababbbbabbaabaaabbababbaaaaabbaaabaa
+bbabbbbaaabbaabbabaabbaa
+aaabbaabaabaabbaabbaababaabbbaabaabaabbababbabababaaabbbbbabaababaaaababbbbbbbbabababbba
+abababaaabbaabbabbbbaaaa
+abaabbbaaabbbabaabababbbabaaaaabbaaaaabaaabbabbbbaaaaaabbabbabab
+baabababaabbaabbbbababba
+abbaaabbabbaabaabbabbaab
+baabbaababaabaababaaabab
+abaabaaaaaababbabbabbaba
+baaabbbbbbbbbbababaabbab
+babaaabbaabaabbaabbabababababbba
+aaababbaaabaabaabbbabbbababbbaabaabbbaaa
+aabbaaaaababbbbaababbaaa
+babaaaabbbabbbbababbbabb
+bbbaabbabbbaabbabbabbbaa
+babaaaaaabbaabbabbaabaabbbbbbabbbbaaabbabababaaaaaabbbbb
+babbaaaabbbbababbaabbbabbaaabaabbaabbbba
+bbbbbbaabaaababaababbaabababbbab
+abbabbbbaabbbbaaabbbaabbbbabbabb
+bbbabaaaaabbaaabbabababb
+abbaabababbbbaababbabbabbabbaaaaaaaaabaaaaaabaab
+aabbabaabbababaaaaabbababbaabaaabaaaaaaa
+bbbbaabbbbbababaabbbabaaaabababb
+baabbabbaabaaabaaabaaabababaabab
+baabaaaaaabbaaabbbabababbabbbbbbbbbbaaaa
+aaaaaaababaabbbabbaabbbaaaaabaababbbaaababbbaabaabbbbbbbababbababaabbaab
+abbabbbbbbbbbabbababaaaa
+babbbaabaabbbbabbaabbaabbbbabbaabbabbaab
+ababaabbbbaabaabaaabbabbbaaaaaaa
+baaaaaabaabbaaababbbbabbabaaababbbaaaaba
+bbbbabbaaabbbaabbaaaabab
+ababbbaaabbabbabbbbabbab
+abababaaaaabbabbbbabaaba
+aaaaabbabbabbbababbbabba
+aabbbbbabbabababaabbaaabaaaaabbbbbbaaaab
+bbbabaaabbbabbbaaaabbababbbbbaba
+aaabaaababbbaababaabbbaa
+aaaababbbbbbbbabaabbaabbabbbabbbbababaaabbbaabbbbabbbbab
+aabaabbabaabababbabaabbaaaaaabab
+abbaabababaabaaababbbbaaaabbaaba
+bbabababbaabaabbababbaaa
+babaaaabbaabababbbbaabbaaaabaaabbababbaaaaaabbaabbbaaaaa
+bbbabbbababbbbbbbaaaabaa
+bbbbabbaababbbaabbabbbbabbabaaaaaabaababababaababbaababbbbbbaaaa
+baabbbbaaaabbbabababbaba
+aabbbbabbbbbababbbababbbababbaaaabbbbaaa
+aabbaaabbbabababbbbabbbabaabbaaababbaaababababba
+baabaabbbaabaaababbbbaabbaaaaababababbbabaaabbbbbaababababaaaaaa
+bababbbbaabaaaababbaaabbbabaabab
+babaabbbaaaabbbaaaaabbbbabbbaaaabbabbaba
+abaaaaabbbbabbaabbbbbbabaaabaabb
+ababaababbaabaabababbaba
+baabaaaabaabbabbbbabaaaababbaaab
+aaaabbbabbbbbbabbbabbabb
+bbbbbbabbabbaaaaabaaabbabaaababbaabbbaaa
+bbbbbabbbbbaababbabababb
+aaabbaababababaababaaabbabaaabbb
+baabaabbaaaaabbabaabaaaaabaaabab
+bbbbbbababbbbaababbabbabbbbaabaa
+abaabbabbabaababbbbbbbbabbbbbbaaabbbaabaabbbbbbbbbbbaaab
+abaabababaabbabbbbbbabbabaaabaab
+bbabbbababbaabbaababbbbaabbaabbbbbaabaabbabaababbbababbbbaababaa
+abbaaaaaaaaabbbaabbabaaaabbaaaaaababbabaaaaabaabaabababb
+aaaaabbaaaabbbbaaaabbbbaaaababbababbbaabbaababbababaaabaaabaaabbbbaaaaab
+aabaabbaaabaaabaaabababb
+aaabbabbabaaaaabbbbbababaaaabaaa
+baababababbbbabbabbabaaaaabaaabbaaababbb
+ababbbbaabbaabbaabbbbaaa
+aaaabbabbbabaaaaaabaabbb
+bbbbabbaaaaaabbabbbababa
+aaaaaabbbabaaababaaabbaaabaabbbabaaababbbbabaabaaababaabaaaaaaaaabbbaaaababaabaa
+baabbbababbbbbaabaabaaaaaaabaabb
+abbabbabbbbbabbbaaaaabbabaaabbaa
+baabaaababaabaabbaabbabbaaaaaaababbabaaaaababbba
+baaabbabaaaaabaaabbabbbaaababbba
+aabbaaababaabaaababbaabaaababbabbabbbbabbbaaaabb
+baabbaaabaabbaababbbbaba
+aaaaabaabbaaabbaaabaaaabbaabbaaaaabaaabb
+bbaababaabaaabbababababb
+bbabbabbbbaaaaaaaaaabaabbbaaabaabbabbabbbbbbabbbabbbaaaabaababbbbabbbbabababbaab
+aaabbbbabaabaaaaaaabbbab
+baabbbabbbbabbaaabaaabab
+bbaaabbabaabababaabbabbabbaaabaa
+ababbbaaababaabbbabaaaabbababbbbbaaaaaba
+baabbaaaabaababaaabababb
+aababbabbbababababbbbbaabaabbaaaaaaabaaabbaaaaba
+aaaaaaabbaabaaaaababababbabbaaabaaabaaba
+abbaabbbaabbbabbaaabbaaa
+baabbaabbbbababbbaaaaabbbbabbabb
+aaaaabbababbaaaaabaaabbaabaabbbabaababaa
+aabbabbbbbbbabbbbbbbbbba
+abababbbaaaaaaabaabbabbaabbbbaaa
+abababbbaabaaababbaababaabbabbaa
+baabbaabaaaaaaaaaaabaaba
+ababbbaabbbbababbbaaaaab
+baaabbabaaabaaabaaaabbbbbaaaaaba
+bbaaabbabbabaaaabbaaaaaaababaabbbabaaaba
+abaabbbaabaaabaaaabbbbbbbaaabaabaababbba
+bbbbabaabbbbbaababaaaaabaaabbabbbabababbbaabbaaa
+abaabaabaaaaabaababaabbbbbaabaaaaaababbb
+aabbbbbaaabbbbabaabaaababbbbbbabbbbaabbbbaabbbaa
+abaabbbaabaaaaaaaaaabaaa
+baabbbababbbaababbabaaba
+babbbaaaaabbbababbababbabbababab
+baaabbababbbabbbabbbbbba
+abbaaaaaabaabaabaaabbbbaabbababbababbaaa
+abbaaaabbaaabbababbaababaaaababbbabbaabb
+baabaaabaaabaaabbaabababbaabaaba
+ababbbbaabbaaabbbbaababaaaaabbbbabbababb
+baabbabbbbabbbbabaabbababbbbababbaaaaaababababba
+abaabaaaabbaaaababbaaaabababbbaaababbabaabaabababbbbbaab
+abbbbbabbaaaaaabbabaaaaabaaabbbbbaabababaaababaaabbbabab
+baabaaabbabbabababbaaabbbabbabbabbbbbabbbabbbaaabaaaabab
+babbabaaaaaabbbbabaaaaabaabbbabbabbaaaaaaababbba
+babbbabaabbbaaaababaabaa
+aaabbabbbabbabaaabbbbabbabbababbabbbabba
+abbaaaabaaabaaabbaabbabaaaababbabaaabbbbbababbaaabbabaab
+aabbabaabaaaaabbaabbbaabbabaabab
+baaaaabbbbaaaaaaabbbbbabbbbbbbbbaababbbbbbbaabaa
+bbababaaabbaabaabbabababbabaabbbabbaaaaaabbbabbb
+aaaabbabbbaabaabaaaaaaaaabbbbbaaaaabbbababbbaaaa
+abbabbbbbbbbabababaabbab
+babaabbabbbbabbabaaabbbbbbababbaaaabbbabbabaaabaabbabaab
+bbababaaaabbbabbbbababbb
+baabbbababbaabaabbbbababbababbbbabbbabab
+baabaaaabbbbbbababbabbaa
+babaaaaaaabbbaabbbbbbbaabaabaaabaaaaabbbabaaabbb
+aaababbaaaaabbbbbbabbbba
+aabbbaabbbabaaaaaabababaabbbabbbbbaaabaabbbaaaba
+abbbabbbbabaaabbbbbbababababbbbb
+abbbbaabaaaabbbaaaabbbbaaaaaabab
+ababbbbaaabaaabaababaaab
+aaaaaaabbbbaababbaabababaabababaabbbbabb
+aabaaaabbaabaaabbaaaaaabbababbbaababaaaa
+aabbabbabaaaaabbaaabbbab
+bbbbbabbbbbbbbabbbabbaba
+aabaababaaaabbabbbbaabbaabaaabaabbabababbbaabbbbbaaaabaa
+babbabbabbbaababaabbbbbbabbaaabaabbabbbaabbbbbbb
+aabbaaabaababbababaaabab
+abaaabaaaababbabbbbbbbabbbaaaaaaabbabbaaaaabbbbb
+babbbbbbbbaabaaabbbbbaba
+aababbaaaaabababbababbbaabbbabaa
+abbbbbaaabbbbaabaaaabbbbababbbabbbaabbaa
+aabbabbaaabaaabaaaaabbabaabbaabbabbbbbabbaabbbba
+baabbbabbabbaababbbbabbb
+aaaaaaabaabaaaaabbbbbbbbaaabbabbbabaabababababbb
+bbabbbabbabaaaabbaabbbabaaaabbbabaabbabbbbabbabbabbbaabbbaabaabaaababaaa
+bbaabaabaabbaaaaabaabaaaaabaabbbbababbaa
+bbbababbabaaaaabbbbabbab
+abbbabbbaabbbaabbbbbabbababaaabbabbbbbaabbaabbbbabbababbabbbbbbb
+babbabbaaababbabbbbabbbaaaabaaababbaabaaabababab
+bbabaaaabbbabbbaababbabbaababbaa
+abbbbabbabbaaaaaaaababaa
+bbbababbabbaaabbaabbabbbbbbabbbbaaaabbaa
+abbabbbbbbbaababbaabaabbbbabababbaaaaaaabbbbbababbabaabb
+aaaaaababaaabbaaabaaaabb
+babbababbabbbaaababbbabbbbbabaab
+aaabaaabbabaabbbbababaabaabbbbbaaabababb
+aabbbbbaabbbbabbbbbbababaaaaabbaabbabbabbaaabbbbbbabbabb
+abbabaaababaabbaaabbaaabbaaaababbbbbbbba
+bbbbbbabababababbbabbbabbaaaaabbabaaaabaabaaaababababbaa
+abbaabaaaabbabbbabaababaababaabbbbbbbaba
+abbabbbbbabbaababbbaabaa
+abbaababbababaabbbaaabbaababbbaaabaaabaabbaaabbb
+bababaabaaaababbbbaaaaaaaaaaabab
+bbbbabbbbaabbabababbabbb
+abbaaaabaaaaaabaabaaabaaabbbbaaabbabaaba
+bababbbbaaaaaababaabbabbbbaabbab
+abbaaabbababaabaabaabbab
+aabaaaabaabbabbabbbababa
+aaaaabbabbbbbbaaaaabbabaaaaaaaaaabbbbabbaabbabbabbabbbaaaaabaabb
+bbbbbaaaabababbababbbaabbabbbbaaaabaabaabaabaaababbaabababbabbbb
+abaabaabaabbbbbbaaaaabab
+aabbabaaababababbbbaabbaabbbbbaabbabbaabaabaaabbbaabbbaa
+abaaaaaaabbaababbbbbbabbbbaabbab
+babbabaabaaabbbbabbabbaa
+aabaaaabababaabaaabbaabbabbbabababbbbbbb
+aabbaaaaaaabaaaaabbbbabbbaabbbababbaaababbaaababbbaabbbb
+aaabbbbabbbbbbbbbbaaabab
+aabbbabbbaabaabbaaaaaababbabbbbbbbbaabbb
+bbbababbbababaabaabababb
+aabaabaaaaaabbabbaabbaabaaababab
+babbbaababaaabbaabbaaabbbbbababa
+baabbaabbbaaaaaaaaaabbabbabbbaabbabaaabbbbaabbbbbbbaabaaaabaaabbabbabbaa
+abbaababbabaaaaababbbaba
+bbabababaaaaabaababaaaba
+aaaaaababaaaaabbaabbaaabaaaaababababbaba
+babbbbbbaabbaaaabbbbaabb
+ababaabbbbaabbbaababbbbb
+bbbabbbaaaabbaabbabbbbaa
+aabababaabbaaabbabaaaaba
+baabaaabaabbabbabbbbbaaa
+bbbbbbbbbbbabbaabbabbbbabaabbaab
+babbaabaaabaabaaabaabbbabbabbbaa
+ababbbbaaaaaabbaabbaaaabbbaababaabbabbabbbbabbabaaaaababbaaabaab
+aaaabbabbaaabbabababababbaababaa
+aaabaaabbabbaaaaaaabaaaabbbbbbbaaaabaabababbbabbabaaaababbbbabaa
+babaaaaaabbaabbbbbababaababababb
+bbabbbabbbaabaaaabaaabbabbbbbbba
+abaabaaaaabaabaaababaabaababbabbbbababbb
+bbaabababbbaababaaabbbbaabaaaaaaabaaabbb
+aabaabbaabbbbbaabaaaaaabbaabbababbaaabbaaabbabab
+baabaabbaaaaaaabbaaaabab
+baaabbababbabbbbaabbabab
+aabbbbbbbaabbababaabababbabababbababbaaa
+bbabbbbbbaabbabbabaaaaaabbbbaabb
+aabbaaaaaabbaaaaaababbbb
+bbbbabbababbabaaababbbbaabaaaaba
+bbbbbbaaababaabaabbbbaababbbbbabbababbaa
+aaaabbbaaababababbbaaabaabaaabbbbabaaaabaabbbaaa
+bbabbbabbbbbbbbbababaabaabbbabaabbaababb
+aababababbabaaaaababaaaa
+babbaabbbaaaababbbaabaaababbabaaaabaabaaabbaabbabbabbbbbabbbbbab
+aaabbabbaaaaabbaaabbbaabaaabaabb
+abbbaababbbababbaabbbbbbababbbab
+bbbabaabbaaaaaabbbbbbaababbaaabaabbabbbbaaaabbaa
+aaabaaabababbaabababaaab
+bbbbaabaaabbbaabaababbabaabaaaabaaaabbaaaabaaabb
+aaaaaaaababaaaaababbbaabaaaaabbababbbbba
+abbababbbbbaaaababbaaababaaabaababbabaaabbbbbabaababbabbaaabbabaabaabaab
+aaabaaaabbabaaaaababaabaabbaaaaaaababbabbababaaa
+baabbabbabababababbabbbbbabbabbb
+abaaabbaabbbaababbbbaaabbbbbbabbaabaababbbbaaaba
+ababbaabaabbabbababaaaabbaaaabbabbaabaababbbaabbbabbbbabbbbbaabb
+baabbbabaabaabbaabbbbaaa
+abababaaaaabaaaabbbbbabbbbaababb
+ababababbaaabbabababaabbabbaabbbbaaabbababbbbbbb
+abaaabbabbaabbbabbaabababbaaabbb
+babbabaabaaababababbbbaabaaaaaabababbbaabaabaaba
+babaaaaaababaabbabaabaabababaabbbbbbabbbaabbaababaababbaaababbbbbbbababa
+baabaabbaabaaabaaabbaabbabbabbabbbaaaaaaabbbabab
+bbbaabbababbaaaabbaaabbb
+aabaabaabbbbaaababbabaaaababbabbbbbabbbaabaaabbbbbaaabbbaababaab
+aaababbbbaababbbbabbaabbabbabaababaababb
+bbababaabbbbabbaaabbabbbababababaabbaaabababaaaa
+bababaababbaaabbaaaabbaa
+abbbaabaaabaabbbaabbbababbbbabbaabaabaaaaabbbabaaaaaabbb
+aabaabbabbabbbbbbbaaaaab
+bbbabbabbbbaabbbabbbabab
+bbaaabbaabaaaaaabbaaabbb
+aaaaabaabbabaaaababbbabb
+aaaaaaaaabbabbbbbbabbbbbaababbaa
+bbbbbbabbbbbabbbabaaabab
+abaabbbaabaababaaaaaaaababaaaababbbbaaaa
+babbbaabbabaaabbbaabbaabbbbabaaaaaabaaaabbbbababbbaabbbbbbbbbaab
+aabbbaabaaaabbbbaaababbabababaabbbbbbbbbbbbababbbbbbaaaaabaaabbbaababaaabbaaaaabbbbaabaa
+aaaababbaabbabaaabbabbbaaabbaabbbbabbbbaabbabbaa
+bbaabbaabbbaaaaaaabaaabb
+babaabbbababaabaabaaaaaaababbabbababaabbabbbbaba
+aaabbabababaaaaabbabaaaaaaaaaaabbbbbaabaaaabbbabbbbbbaab
+aaaaaaaaababbaabaababbaa
+bbabaaaabbaaaaaaaabbbbbbaabaaaaa
+abbabaaaabababaabaabababbaaabaab
+abababbbaababbabbbbbbbbbabbbbabbaababbabbbaabbabbbabbbaabababbab
+babbbbaaabaabbbaaaabbaaa
+bbbbbbaabbaabaaaabbaaabbbbbabbbbbbbabaab
+babbaabaabbabbabbaababaa
+abbaabbabaabbaaaabaaaabb
+babaaaabbabbbbbbaaaabbaabbbabbababbbbaba

2020/src/main/resources/day21.txt

@@ -0,0 +1,49 @@
+chsprq bdghf dtpcd djtblr kggl cvdvd jzlht lkdg nd szvsg drv ptn mhjg dnlsjr rhvglf fmgg prkpfnh tfdl bcthd lmxc hjpv rsvlb hgmq xsvjb cqgqxq vsvmt ccd sqdsxhb vpzhpnx dlj dvqsf mmr bmtn vgqd zfrn zffphr nlmsj xxhf rfdxph ggqlkpr cmfj bfkm stcctv rlnsc snngn xzb zjfb qdccb qxrm jlhv vfpmcdc gbnj srhmt lfrq blcb jcnglmz bhrjc qmvzln nllmj zqhxc xpk drchk pbhthx qks dgvqv tcph (contains fish, wheat, shellfish)
+cvdvd lkdg dgvqv czd mjnjq kxkzv bdghf xzb xsxkj bfjlcv sbkq gsmvb cvrzmd prspxdl pbhthx sqdsxhb ppfmb zffphr chmmqq htfvt ccd szd qks qthvbf prkpfnh xdlhgf rqhp fmgg mxqht mdpqq phh xrstpzc chxkn vgqd qmvzln prg vfpmcdc fsgj zgfr cqgqxq hfl csnfnl pcg ghrnk hmrh kdkrhr qldrh rsvlb lczvhs xsvjb qsndg rlnsc djtblr ffpq snngn zbs dvqsf qsvfk hmcc blgxsl (contains dairy)
+bmtn ptn pmvgd zffphr cfjqbs chmmqq prkpfnh jzlht mxqht xzb blgxsl pdzqrqq pbhthx vpzhpnx fmgg xpk prg mjnjq kggl mhjg mmr fmgnz msdgp dnlsjr zgcrp bdghf ctfdj dgvqv snngn ghrnk tfdqg hctzvvc ddbss xmnqb htfvt sqdsxhb zbs ccd xsxkj jfzd djtblr tltxb ktgqdf cspz qdms jtl mdrn rvmx jsxqj kdtr xrstpzc cfzcl lkdg zjfb nrsb rsvlb (contains shellfish, dairy, wheat)
+dgvqv xrstpzc prspxdl ptbvs kfl vsvmt dsjrv tbfmsnj cvrzmd chsprq jlhv vpzhpnx zjfb pmvgd qklrs kdkrhr kvtlklq jsxqj ptn vgqd sbkq lkdg fmgg sqdsxhb zfrn pbhthx drv txnxdd bdghf rsvlb hjpv cfjqbs csnfnl sdvc chmmqq cspz xdjz fqpjl zrlpbh tnhjq vtjmvd nrsb rnpjxc mdpqq bfkm rfdxph lzbfz ppfmb dptx fmgnz bhrjc qldrh qksrp dtpcd zspn qdms kdtr jzlht xzb nrgcrd (contains soy, eggs, shellfish)
+zspn dnlsjr bmtn rdnvlt dlj blgxsl qthvbf qsndg dptx rsvlb bqdbr rlnsc bsnvm cfzcl kggl lcgdsp ffpq sqdsxhb mppxj hmcc pbhthx qxrm csnfnl mpnd fmgnz qdgdsg qklrs blcb cpp ctfdj cfkdn ktgqdf dvqsf jsxqj xtnz cfjqbs zbs sbkq gsmvb hgmq jcnglmz cvdvd kbfqvxf kfl cmfj lkdg pdzqrqq dgvqv xdlhgf qks ndfmx hfl tbfmsnj hmrh xlttl ppfmb zgcrp tsqp djtblr zdkgvxk drvxr xsvjb bbztv qmvzln cqgqxq ptbvs (contains soy)
+ktgqdf hnnk fqpjl phh hmrh dnlsjr lkdg qdccb bmtn pbhthx lzbfz nxlq msdgp chmmqq rsvlb kfl vpzhpnx ccd szd bdghf mbbz hfl vbdsgx dvh lcnnf vtjmvd drchk cvrzmd bhpn bqdbr xpk qsndg fmgg snngn qksrp dgvqv csnfnl hgmq fsgj jtl zfrn cfzcl bbztv tsqp drv kxkzv xmnqb mpnd xzb chxkn qks rfdxph prkpfnh gsmvb nrsb htfvt qthvbf pcg xdrm ctfdj dxqbf zdkgvxk dlj kggl srhmt drvxr fbj sdvc tfdqg dxn jfzd cqgqxq cspz fmgnz ndfmx bplgpn rnpjxc (contains wheat, dairy)
+blcb sqdsxhb lkdg kdkrhr nd phh sdvc qldrh zspn jcnglmz qsndg lzbfz xdrm rsvlb kbfqvxf cspz gdg xmnqb qxrm chxkn xtnz cvrzmd chmmqq fmgg dxqbf mdpqq vpzhpnx ccg mbbz rdnvlt zjfb ssjpd bqdbr qdgdsg jsxqj fktqdh kvtlklq dnlsjr tcph cmfj tfdl qtkbvr qgxj qphl zrlpbh stcctv rqhp qmvzln fbj prspxdl xzb dgvqv kfl mhjg jtl csnfnl ccd dvqsf dvh vtjmvd vgqd lmxc fsgj zqhxc tsqp zffphr (contains wheat)
+stcctv fsgj sqdsxhb hctzvvc mxqht tcph bdghf dnlsjr rfdxph vpzhpnx rhvglf ctfdj czd nlmsj bhpn bmtn vgqd ppfmb xzb msdgp kfl dvqsf sbkq bcthd qdgdsg csnfnl dptx cpp zgfr jcnglmz pcg vfpmcdc hnnk gsmvb qdccb xsvjb rnpjxc zdkgvxk jtl gdg nrsb dcmpb rhqfkmn jgnxfn cvdvd dgvqv mdrn zbs hcgh kxkzv tfdqg dxqbf pmvgd hjpv hmcc srhmt szvsg ssjpd xdrm lcnnf zrlpbh pbhthx tvkvmms ptbvs nrgcrd lkdg (contains fish, sesame)
+hctzvvc drvxr dxqbf vsvmt cqgqxq rfdxph zgfr dvh kpbg lkdg vtjmvd tfdqg dgvqv hcgh jzktf chxkn jlhv dnlsjr chmmqq jtl cfjqbs xzb fmgnz ghrnk prspxdl dxn dlj bplgpn hmcc xdjz bfkm szd qgxj zspn hnnk srhmt hgmq fktqdh xrstpzc szvsg mjnjq xmnqb sqdsxhb qdccgvb zrlpbh gbnj ptn ffpq sbkq bhpn ddbss rsvlb lmfccx qklrs rnpjxc cfzcl phh xsvjb qthvbf zdkgvxk czd bdghf tvkvmms fsgj prkpfnh rrjt ptbvs mxqht csnfnl qxrm rhqfkmn xtnz kbfqvxf gjbfmm rqhp bmtn bhrjc drv ktgqdf zffphr hjpv cspz (contains wheat)
+nd prg djtblr lrgxlct mppxj zgcrp lkdg kvtlklq zrlpbh rdnvlt rnpjxc xmnqb hctzvvc jfzd tnhjq fsgj vpzhpnx zdkgvxk ctfdj cspz phh zffphr xxhf gjbfmm jsxqj mpnd ggqlkpr qldrh chxkn fqpjl mbbz qdccb pbhthx ktgqdf hfl drchk cvdvd pcg ccg bsnvm nxlq prkpfnh csnfnl jtl qdccgvb jgnxfn tltxb nrgcrd ftzgp sqdsxhb sdvc bfjlcv xzb bfkm bbztv tbfmsnj dnlsjr drv rsvlb qdms cmfj chsprq bcthd drvxr dtpcd kggl ndfmx xdjz qksrp lczvhs gbnj lcnnf vfpmcdc dptx zqhxc qklrs (contains eggs)
+bhrjc lkdg vtjmvd ffpq cvrzmd ndfmx djtblr sqdsxhb nxlq gsmvb hfl chsprq dvqsf csnfnl ccd fsgj cqgqxq qklrs xzb qxrm gjbfmm ktgqdf xmnqb zspn tbfmsnj hctzvvc lczvhs kggl bhpn rhqfkmn tfdl ssjpd msdgp txnxdd nd blcb kbfqvxf gdg ghrnk dcmpb kvtlklq phh rlnsc qtkbvr dlj qphl tnhjq zbs mppxj stcctv dnlsjr xtnz jtl zffphr xdlhgf vbdsgx rsvlb hhxrrr blgxsl zgfr dgvqv xdjz jfzd chmmqq bsnvm czd lfrq (contains wheat, eggs)
+tvkvmms xzb fbj rhqfkmn qdgdsg rrhsh sqdsxhb tfdqg qxrm rqhp ctfdj qthvbf tfdl czd zbs nlmsj xpk cmfj qtkbvr blgxsl vfpmcdc gbnj prkpfnh zqhxc cfkdn mhjg bsnvm fmgg xmnqb qdms dnlsjr rsvlb hgmq csnfnl dgvqv hjpv dxqbf bmtn pbhthx stcctv qks (contains nuts, wheat)
+szvsg zrlpbh xsvjb ktgqdf bbztv xxhf bcthd qklrs ctfdj sqdsxhb xzb lkdg txnxdd sdvc pbhthx mbbz cpp dsjrv xdrm mdrn hmcc rdnvlt xdjz mhjg ptn kdkrhr rrjt xdlhgf qdccb rsvlb qmvzln qdccgvb jzktf zfrn lczvhs kfl dnlsjr xmnqb csnfnl bdghf ppfmb (contains nuts)
+jgnxfn zdkgvxk prg dxqbf mxqht kdkrhr mhjg pbhthx dgvqv tcph zffphr cfzcl qthvbf xxhf bfjlcv hmrh mdpqq ccd cspz mppxj nllmj lkdg qmvzln zgfr fmgg qtkbvr bmtn hhxrrr nxlq xzb ccg dptx sqdsxhb gdg gjbfmm prkpfnh ktgqdf qdccb tvkvmms mbbz qks lrgxlct dnlsjr cfkdn bfkm ppjrrm csnfnl rhqfkmn lzbfz jzktf szvsg (contains dairy, fish)
+fktqdh zspn gjbfmm bmtn ccd hfl ftzgp zrlpbh bhrjc lfrq rrjt rvmx pbhthx sbkq jfzd zdkgvxk xdjz srhmt sqdsxhb dlj rsvlb qmvzln vbdsgx drvxr xmnqb sdvc mbbz bplgpn blgxsl hnnk zgfr ptn hcgh xlttl dnlsjr qthvbf lzbfz qtkbvr rnpjxc qsndg ktgqdf dtpcd gdg kfl csnfnl rdnvlt zjfb tbfmsnj ddbss dptx gsmvb lcnnf szd bqdbr lczvhs cmfj drv tqgd kvtlklq mmr ctfdj zgcrp prspxdl fsgj zffphr ccg blcb qdms jlhv xzb dgvqv zqhxc (contains sesame)
+sqdsxhb tfdl dgvqv xpk xzb csnfnl ftzgp mbbz xrstpzc nlmsj rvmx ccg fmgg xlttl dtpcd qphl nrgcrd rdnvlt lxfbmt dnlsjr drv fbj bfjlcv htfvt lkdg nllmj lcgdsp cvrzmd qthvbf hmcc hfl prkpfnh dvqsf hhxrrr cpp kbfqvxf xsvjb kvtlklq rqhp pcg lmxc jgnxfn nd lrgxlct ppjrrm djtblr sbkq ffpq qdms prspxdl qxrm zffphr cspz chxkn rlnsc pbhthx tsqp nrsb mpnd xxhf (contains dairy, eggs)
+dsjrv zbs zfrn lkdg hfl tfdqg lcnnf rrjt cvrzmd qdgdsg tvkvmms hcgh fmgg dxn ptbvs xsvjb xzb gsmvb nrsb rsvlb zrlpbh hmrh vbdsgx prg bbztv zspn pmvgd srhmt cfzcl ppjrrm rrhsh cmfj rhvglf csnfnl prkpfnh hmcc mppxj pbhthx dtpcd mbbz zffphr rfdxph dnlsjr sdvc sqdsxhb ktgqdf (contains soy, eggs)
+htfvt rsvlb qthvbf txnxdd cpp jtl bbztv lrgxlct chmmqq qdccgvb bfjlcv zffphr xzb jgnxfn hctzvvc dvqsf kpbg rnpjxc dgvqv lzbfz zspn zfrn sqdsxhb blcb jzktf xdlhgf dxqbf pdzqrqq ftzgp xpk sdvc djtblr kxkzv xdrm pbhthx csnfnl qsvfk snngn jlhv vgqd vpzhpnx jcnglmz nd lxfbmt drv mpnd cmfj cspz pcg bfkm dnlsjr qphl qks bsnvm bcthd (contains eggs, fish, shellfish)
+kbfqvxf tnhjq kggl vfpmcdc prg zfrn jcnglmz tvkvmms fmgg rsvlb zdkgvxk qsndg vgqd tltxb ndfmx dgvqv bmtn gjbfmm dnlsjr dxqbf szd lxfbmt drvxr sqdsxhb rfdxph nrsb ppjrrm mdpqq zjfb pbhthx bhrjc rqhp qmvzln vbdsgx ccg csnfnl blcb hcgh mmr cfkdn gsmvb xzb (contains wheat, fish, shellfish)
+nrsb jfzd lcnnf rsvlb bdghf cvdvd cpp ggqlkpr xpk xlttl hjpv cvrzmd mdpqq mhjg htfvt ftzgp zffphr djtblr rfdxph qxrm pmvgd fmgg tbfmsnj bqdbr qgxj hmrh nllmj qdms sbkq qphl lczvhs stcctv drv lfrq fsgj xtnz dnlsjr csnfnl gjbfmm vtjmvd ccg qdccb phh lcgdsp prkpfnh hctzvvc tsqp qldrh jzktf tvkvmms dgvqv pbhthx chsprq ktgqdf mmr hmcc xsxkj sqdsxhb dxqbf xzb cqgqxq jlhv mdrn blgxsl bplgpn szvsg ctfdj ptn bcthd ddbss kdtr zrlpbh fbj gbnj qsndg kdkrhr gsmvb tfdl (contains nuts)
+cmfj jzktf rdnvlt ftzgp qtkbvr lcgdsp prspxdl htfvt drv rrhsh qdccgvb zdkgvxk msdgp vfpmcdc fsgj nd lmxc zgcrp cfkdn dxn tltxb mmr dlj nlmsj bfkm hcgh dsjrv qgxj hjpv vsvmt lzbfz xxhf zspn qdccb xzb drvxr pcg dnlsjr chsprq kxkzv lfrq tfdl gsmvb csnfnl ccg pbhthx blcb lkdg dvqsf sqdsxhb xdjz lcnnf dptx xsxkj jlhv gdg rrjt dxqbf dgvqv (contains shellfish)
+tsqp jgnxfn rvmx rhvglf szd qdccgvb gjbfmm rdnvlt xpk ssjpd fmgnz bqdbr vbdsgx fmgg pbhthx dvqsf ptbvs blcb kbfqvxf bfjlcv hjpv msdgp gbnj kfl vfpmcdc cfjqbs pmvgd fktqdh csnfnl xzb qdccb qdms ffpq bhrjc lrgxlct rhqfkmn ggqlkpr jlhv qklrs mxqht tvkvmms kpbg prkpfnh mmr nxlq nrgcrd chsprq djtblr rlnsc ccd sqdsxhb drchk vpzhpnx cfkdn mppxj lkdg ktgqdf cpp prg srhmt xdlhgf kdkrhr xmnqb rqhp qthvbf zrlpbh gsmvb lxfbmt ndfmx sdvc ddbss xlttl dnlsjr hhxrrr tfdl qxrm qphl dxn rsvlb tbfmsnj qksrp bdghf xdjz qgxj xsvjb mpnd qks jzlht (contains dairy, soy, shellfish)
+txnxdd kdtr szvsg xsvjb bbztv lkdg vsvmt bqdbr qdccgvb blcb sqdsxhb stcctv xzb jtl qphl csnfnl nrgcrd mjnjq lcnnf xlttl zgfr gdg vbdsgx drchk mhjg bhrjc mxqht fqpjl rrjt nrsb lmxc qks dvh pbhthx kggl jcnglmz dnlsjr dtpcd hhxrrr vpzhpnx fsgj tnhjq ktgqdf rsvlb tqgd rrhsh kpbg chsprq gbnj dptx ghrnk msdgp qdms hmrh kvtlklq mdrn zbs tltxb zfrn nlmsj zspn kdkrhr xsxkj ppjrrm cqgqxq lrgxlct kfl jgnxfn (contains sesame, dairy)
+jzlht lmfccx gdg bqdbr cmfj jlhv bcthd ccd lzbfz vpzhpnx hnnk fktqdh zfrn chxkn bfjlcv xmnqb chsprq ssjpd qklrs qdms ccg hhxrrr kggl vbdsgx nrgcrd xzb cfkdn mppxj lkdg lfrq dnlsjr ffpq bsnvm xsvjb dgvqv qphl rhqfkmn dptx rsvlb szvsg dcmpb mdpqq bfkm rvmx dxqbf zrlpbh bdghf cvdvd drvxr kdkrhr stcctv qdgdsg htfvt lmxc tsqp bmtn xdjz pbhthx blgxsl dtpcd ndfmx qdccgvb zbs tcph drv rrhsh tbfmsnj djtblr qsvfk bbztv sbkq prg kpbg sqdsxhb (contains dairy)
+zgcrp dsjrv blcb kfl bqdbr rvmx jsxqj ssjpd lmxc rnpjxc rsvlb kvtlklq zffphr zfrn qthvbf czd mbbz ndfmx xpk chsprq nrsb vsvmt dcmpb cvrzmd lczvhs nxlq gbnj rrjt bplgpn pbhthx hjpv ffpq rlnsc xzb fmgnz dnlsjr blgxsl csnfnl zqhxc hcgh sqdsxhb ccg tsqp fbj rdnvlt mxqht vtjmvd dgvqv xxhf chxkn zspn (contains shellfish)
+sqdsxhb ghrnk bfkm rdnvlt bbztv hgmq kdtr rvmx cvrzmd rqhp dxqbf ptn kbfqvxf vpzhpnx dcmpb xdjz pbhthx qphl qdms jfzd pcg ffpq ctfdj hfl dnlsjr qmvzln zspn lfrq ggqlkpr bfjlcv cpp tnhjq bmtn csnfnl mbbz qdgdsg fmgnz ptbvs jzlht mdpqq qdccb ccg rnpjxc msdgp kdkrhr lcnnf gbnj jgnxfn xzb snngn qgxj qklrs bhpn czd kpbg rsvlb dsjrv ftzgp zqhxc hmrh fmgg phh szvsg prg jcnglmz ddbss zrlpbh djtblr tfdl pdzqrqq qks vsvmt nrsb xxhf fqpjl jzktf xdlhgf bcthd qdccgvb zfrn dgvqv chmmqq chsprq chxkn (contains shellfish, fish, eggs)
+dgvqv qthvbf kfl bsnvm dvqsf nd qdccb ssjpd lczvhs lkdg xdjz vbdsgx vgqd cfzcl kdkrhr cvrzmd kxkzv csnfnl bfkm xmnqb qsvfk fsgj ktgqdf vtjmvd bhrjc ggqlkpr gbnj dnlsjr vpzhpnx hmrh hgmq ftzgp rsvlb drvxr jgnxfn qdccgvb snngn ccd rrhsh sqdsxhb lmfccx lmxc zgfr ppjrrm jcnglmz nrsb bdghf xzb ptn ddbss xpk (contains wheat, eggs, shellfish)
+dvqsf prg xdrm fqpjl fktqdh qdccb nrgcrd xpk lkdg bmtn ndfmx ghrnk szvsg pbhthx qklrs mdrn djtblr zfrn chxkn nlmsj srhmt jsxqj gdg jtl qmvzln blgxsl hfl sqdsxhb lrgxlct drvxr lfrq rfdxph jzlht ccg vsvmt csnfnl hmrh xzb jcnglmz mppxj rlnsc tltxb rdnvlt fmgg vfpmcdc ccd dgvqv hhxrrr mpnd rrjt zjfb pmvgd tsqp dvh ggqlkpr vbdsgx tfdl gjbfmm dnlsjr tbfmsnj zdkgvxk qxrm mhjg (contains fish)
+tnhjq ffpq vgqd hgmq qdccb vtjmvd mppxj kvtlklq xdrm gdg ppfmb ghrnk dgvqv dxqbf czd drv xzb xsvjb rhqfkmn dtpcd kfl jgnxfn zgfr nd hctzvvc dlj cfkdn dptx xmnqb txnxdd hjpv msdgp zdkgvxk zjfb ggqlkpr cspz rrjt cmfj hcgh ssjpd sdvc nllmj qthvbf fktqdh dnlsjr fmgnz xrstpzc rdnvlt snngn lmfccx qksrp kdkrhr qklrs mhjg kggl ddbss szvsg sbkq blgxsl lkdg pbhthx ccd lczvhs xpk xtnz stcctv sqdsxhb mpnd rsvlb zrlpbh zffphr hmcc lcnnf hfl hnnk dvqsf cpp (contains eggs, dairy, wheat)
+bmtn tnhjq dnlsjr cfzcl kdkrhr gsmvb ddbss xdjz jgnxfn ghrnk zrlpbh pbhthx qsvfk sdvc pcg cfjqbs gbnj vgqd xsvjb qsndg pdzqrqq zdkgvxk sqdsxhb rdnvlt tvkvmms szd bhrjc xzb dlj lkdg vtjmvd ggqlkpr vpzhpnx nxlq qphl rlnsc bplgpn rsvlb kxkzv qksrp cfkdn mdrn xdlhgf csnfnl tsqp msdgp lcnnf xlttl qdms prkpfnh hmcc mjnjq lczvhs sbkq xdrm tcph ffpq dxqbf ppfmb phh ctfdj nlmsj kvtlklq fbj jcnglmz vsvmt hhxrrr lmxc srhmt hjpv cspz kbfqvxf zqhxc rhqfkmn dxn xsxkj fsgj qklrs nllmj kggl hfl jzktf zffphr lfrq (contains dairy)
+djtblr qdccgvb qphl mpnd mxqht lxfbmt csnfnl chxkn blcb lfrq cspz tcph ffpq mbbz nlmsj fbj kdkrhr sbkq qxrm rsvlb zqhxc qsndg pdzqrqq zrlpbh xdrm xrstpzc lkdg hmrh gbnj lczvhs kvtlklq rrjt rnpjxc hmcc xzb kggl jfzd ppfmb txnxdd xtnz dnlsjr mmr pbhthx bfjlcv nrsb vpzhpnx dxqbf sqdsxhb drchk (contains dairy, soy, eggs)
+qks ddbss hhxrrr kpbg xdjz fbj sdvc fktqdh cpp prspxdl vtjmvd tvkvmms rdnvlt tltxb txnxdd ccd tfdl vpzhpnx dvh rvmx bbztv fmgg bhpn phh pmvgd sqdsxhb pcg bqdbr rhqfkmn ctfdj xdlhgf rlnsc prkpfnh dnlsjr nlmsj cvrzmd srhmt qxrm csnfnl mjnjq ptbvs jzlht lrgxlct dgvqv ggqlkpr prg drchk qtkbvr hjpv jtl rsvlb lkdg mmr qphl lcnnf hfl kbfqvxf vbdsgx jgnxfn vgqd nllmj xzb chxkn szd zgcrp blcb vfpmcdc szvsg hcgh djtblr xtnz tsqp snngn ndfmx (contains soy, wheat, shellfish)
+vbdsgx sqdsxhb xdlhgf tltxb fmgnz zgcrp hcgh xtnz blcb lmfccx qks ffpq dlj qklrs jfzd chmmqq jzktf tfdqg xzb dgvqv ptbvs qdccb gbnj prg drchk ctfdj lczvhs xsvjb kpbg msdgp blgxsl kggl tqgd kdtr fsgj nd cpp drvxr rsvlb xxhf dcmpb csnfnl zgfr cvrzmd lfrq tvkvmms nxlq bfjlcv ggqlkpr kvtlklq vfpmcdc dnlsjr pmvgd kbfqvxf jgnxfn cvdvd bhrjc mppxj jcnglmz lkdg szd gjbfmm xlttl gdg hfl prkpfnh rrjt zjfb bhpn bbztv lrgxlct zffphr cspz vgqd mbbz lcgdsp ccd chsprq (contains eggs, wheat)
+gbnj vpzhpnx kxkzv lzbfz phh hjpv qklrs mhjg zbs hhxrrr qxrm ddbss mdrn lxfbmt vfpmcdc qmvzln hnnk fbj pcg cqgqxq lkdg dvh srhmt cmfj hcgh nllmj rrhsh cfjqbs nrsb ptbvs qthvbf ffpq qsvfk bmtn bplgpn tvkvmms ctfdj chsprq ktgqdf mmr ghrnk dgvqv gdg lrgxlct hmrh kpbg blcb chxkn xzb vbdsgx tbfmsnj bbztv qdms pbhthx rsvlb nd sqdsxhb csnfnl rnpjxc kvtlklq (contains eggs)
+jfzd prspxdl dcmpb fsgj pbhthx vpzhpnx kdkrhr ddbss zdkgvxk ppjrrm blgxsl jzktf qsndg zjfb dnlsjr cmfj qdccgvb nrgcrd lkdg ndfmx hfl bbztv nllmj kbfqvxf drchk xzb lcnnf cfjqbs csnfnl lxfbmt cpp ssjpd rdnvlt kvtlklq rsvlb tsqp lmfccx szd mmr vsvmt nrsb jtl gdg qtkbvr lmxc kdtr dgvqv (contains fish, shellfish)
+cfjqbs cqgqxq dxqbf xpk lmxc sqdsxhb dnlsjr fsgj bbztv gsmvb csnfnl hjpv dvqsf tnhjq ndfmx xdjz lxfbmt lkdg szd vbdsgx qklrs rfdxph jtl mppxj mdrn xdrm pcg bdghf tvkvmms szvsg mmr ggqlkpr txnxdd cfzcl prkpfnh lczvhs nd hmcc bmtn bhrjc dgvqv ccd snngn dcmpb qgxj tsqp qsvfk mjnjq dtpcd drv cvrzmd qtkbvr kvtlklq hnnk hfl bplgpn ptbvs hmrh tbfmsnj rhvglf vsvmt ccg cfkdn tltxb zfrn nlmsj fbj ctfdj msdgp zspn prspxdl qphl xzb rlnsc ftzgp nrsb qdgdsg cvdvd qdccb vtjmvd pbhthx (contains sesame)
+lcnnf bfjlcv zgfr stcctv rhqfkmn prkpfnh ddbss ktgqdf xzb dtpcd zffphr cpp jtl zfrn ghrnk xmnqb dcmpb qsvfk qdgdsg cspz bcthd fktqdh qtkbvr ctfdj dgvqv csnfnl mbbz fsgj cfzcl tfdqg hnnk nrsb bfkm rsvlb qdccb djtblr hcgh nd dxn mxqht qklrs nrgcrd gjbfmm srhmt xtnz hfl lkdg tcph vfpmcdc zspn dnlsjr bhrjc xpk chsprq ndfmx mhjg jzktf prg ggqlkpr qphl dsjrv zqhxc nllmj lmfccx hmcc xrstpzc sbkq ffpq dlj zrlpbh xdjz kpbg sqdsxhb drvxr ccg pcg szd rrjt (contains shellfish, sesame, nuts)
+ffpq sqdsxhb tcph rsvlb prspxdl bmtn rrjt lkdg prg rhvglf dnlsjr chmmqq lcnnf fktqdh qks bsnvm mjnjq zrlpbh bfkm kdtr ptn bcthd qsndg mmr pbhthx zdkgvxk cfzcl xzb bhpn ccd xxhf vfpmcdc dxqbf fmgg jgnxfn gbnj vpzhpnx mdpqq htfvt nllmj csnfnl prkpfnh qdccgvb xpk dptx drv dxn tltxb pcg zspn pmvgd lfrq rdnvlt drchk rlnsc xsvjb lrgxlct (contains nuts)
+dlj rhvglf mppxj qklrs qphl kggl sbkq rsvlb blgxsl tsqp dvh lcnnf xdjz lczvhs csnfnl lcgdsp cvdvd qdgdsg rqhp cspz ktgqdf xrstpzc xlttl hmcc fbj chsprq pcg ftzgp cmfj vsvmt fsgj xmnqb cfkdn vbdsgx dgvqv pbhthx srhmt ptn zqhxc xdrm sqdsxhb rrhsh tfdl rhqfkmn hnnk dnlsjr qdms prspxdl cqgqxq czd djtblr dptx zfrn zjfb kdkrhr bhrjc qdccb dxn xzb qthvbf jzktf bbztv mpnd qxrm kbfqvxf vgqd szvsg xsvjb fktqdh jcnglmz mjnjq szd rdnvlt (contains wheat, fish, eggs)
+dvh rvmx prspxdl lmfccx lczvhs qtkbvr csnfnl qdms stcctv nd vtjmvd lkdg mdpqq tltxb mhjg fmgnz qksrp kpbg kggl ghrnk htfvt jcnglmz xdjz ctfdj xlttl zspn hgmq jsxqj dgvqv ssjpd bmtn hjpv bsnvm dnlsjr czd sqdsxhb msdgp xxhf jtl ggqlkpr sdvc tsqp snngn vfpmcdc jzktf rfdxph xtnz chmmqq bfkm mppxj vsvmt ccg dcmpb nrgcrd kxkzv pbhthx prkpfnh rsvlb bqdbr rrjt zbs jgnxfn vbdsgx mbbz qklrs jlhv rlnsc zffphr xdrm mxqht (contains dairy)
+sbkq mmr jlhv msdgp dgvqv rhqfkmn hhxrrr rnpjxc xsxkj rrhsh mpnd fmgnz xdrm nxlq fsgj qldrh qgxj djtblr chmmqq lkdg ghrnk bqdbr tfdl bbztv szd ftzgp txnxdd ggqlkpr bfkm kxkzv zspn qdgdsg rsvlb nlmsj tltxb cvrzmd dptx jzlht bhrjc xrstpzc kdtr zrlpbh ctfdj ppfmb dnlsjr mppxj rvmx tnhjq jgnxfn sdvc rrjt cfzcl vfpmcdc rfdxph ccd dxqbf lcnnf lmfccx cpp ffpq xsvjb pbhthx xzb cvdvd dxn zfrn dsjrv sqdsxhb vbdsgx hcgh (contains wheat, sesame)
+dptx hgmq lkdg ktgqdf rhqfkmn hmrh dxn ndfmx phh djtblr lxfbmt xmnqb dxqbf qmvzln zgfr zdkgvxk fbj dlj rhvglf hcgh mbbz dsjrv lczvhs zfrn msdgp gbnj qklrs pdzqrqq pbhthx sbkq dnlsjr hfl sqdsxhb xtnz nllmj xzb ghrnk hhxrrr ptbvs csnfnl qdccgvb rsvlb dvh bmtn vbdsgx jsxqj ccd szd rnpjxc dtpcd snngn bqdbr drvxr lcgdsp xdjz (contains eggs, sesame)
+jsxqj hmrh tltxb xlttl zqhxc tcph pbhthx cvdvd ppjrrm ccg bsnvm qmvzln mppxj jlhv rqhp vpzhpnx qtkbvr zgfr fktqdh gdg hctzvvc lcnnf rsvlb djtblr blgxsl fmgg dlj dgvqv qgxj zjfb chsprq qxrm sbkq rrjt jzktf zfrn fbj qdccb jfzd rhvglf xdjz lkdg czd qsvfk pcg rvmx dxqbf snngn bbztv szd chmmqq mhjg sqdsxhb csnfnl srhmt mjnjq fmgnz dnlsjr jzlht kbfqvxf gbnj hmcc ftzgp ssjpd xrstpzc lrgxlct drv cpp kggl (contains fish, sesame, nuts)
+fqpjl phh dlj vtjmvd lmxc ddbss xrstpzc qsvfk jzktf qphl xmnqb ktgqdf qks ccd zrlpbh qdccgvb rlnsc szd nd ndfmx lkdg mjnjq zspn xpk pcg vpzhpnx rnpjxc xsxkj sqdsxhb dnlsjr zffphr lrgxlct lfrq lmfccx ppfmb hhxrrr srhmt fktqdh blgxsl pbhthx qgxj lzbfz ccg rsvlb chmmqq hcgh dgvqv ghrnk lcnnf mdpqq jzlht qtkbvr xdlhgf bbztv gsmvb rhvglf jsxqj hmrh cfkdn xzb (contains eggs, dairy)
+xdjz csnfnl drv rsvlb bmtn bplgpn lcgdsp cvrzmd bfjlcv pmvgd mhjg jtl zspn jsxqj qthvbf fktqdh mjnjq ggqlkpr sqdsxhb qldrh bdghf dvqsf rqhp ffpq zqhxc prkpfnh cfkdn gsmvb vtjmvd qsvfk vpzhpnx tqgd ptn xzb qks hctzvvc xlttl drvxr rrjt cvdvd lkdg hmrh cspz xpk cmfj kggl zgcrp mdrn kpbg tnhjq dnlsjr ndfmx chsprq tfdl qmvzln stcctv htfvt zrlpbh fmgnz dgvqv (contains sesame, shellfish)
+pmvgd lkdg fktqdh sqdsxhb xsvjb rrhsh ptn drvxr qsndg tqgd hctzvvc cqgqxq dlj ppjrrm fmgnz mhjg szd nrgcrd tvkvmms lfrq zfrn hmcc szvsg ddbss qdccb lczvhs stcctv gdg cvrzmd xdjz dxqbf bdghf qmvzln dnlsjr rsvlb lxfbmt vtjmvd mbbz qthvbf ndfmx csnfnl qdccgvb xdrm sdvc dgvqv cvdvd xzb qklrs rhvglf qks kfl czd fbj rnpjxc cfkdn zgfr ppfmb bcthd qdgdsg jgnxfn pcg (contains soy, fish, eggs)
+srhmt vtjmvd bhpn pcg rrjt jzktf tsqp cfzcl qdms vgqd dgvqv qxrm zrlpbh tqgd ssjpd lrgxlct bplgpn ptbvs hmrh lkdg szvsg rfdxph bfjlcv hjpv pbhthx nllmj nrsb prg ghrnk pdzqrqq zfrn qthvbf lzbfz kpbg phh kxkzv vsvmt ppjrrm vfpmcdc xmnqb dlj prspxdl htfvt xsvjb ddbss dtpcd hgmq jzlht xlttl dsjrv chsprq blcb tvkvmms sqdsxhb vbdsgx stcctv gsmvb qks dnlsjr jfzd bfkm qdgdsg msdgp csnfnl dvh mxqht zbs rsvlb cvdvd qdccgvb gdg cspz xdlhgf (contains wheat)
+mpnd dnlsjr nlmsj ptbvs xdlhgf jlhv rqhp blgxsl bhrjc rsvlb mbbz pmvgd rhqfkmn zgfr hmcc hnnk bfjlcv pbhthx xdrm dgvqv bdghf rvmx jgnxfn phh lkdg fsgj mdpqq hjpv rrjt lxfbmt tqgd qgxj ppjrrm jfzd bbztv qks gsmvb xdjz mmr csnfnl hfl chxkn cvdvd vgqd xzb txnxdd hhxrrr lfrq snngn lczvhs ftzgp hctzvvc nrgcrd ctfdj (contains fish, soy)
+ghrnk jsxqj qsndg xdlhgf mxqht vfpmcdc pbhthx mjnjq mppxj chmmqq xsxkj qgxj dnlsjr kfl csnfnl hcgh pdzqrqq hgmq vsvmt dvh vtjmvd xzb kdkrhr zgfr gjbfmm dxqbf qdms hmrh jcnglmz bqdbr rsvlb lkdg hhxrrr ffpq cfkdn dptx prspxdl gbnj xtnz qsvfk nrsb mdrn qksrp jzlht mdpqq jzktf cspz dxn jtl bmtn lzbfz ppfmb hnnk tltxb rrhsh bhrjc hfl kbfqvxf vgqd cvrzmd lmfccx rrjt hmcc qdccb lxfbmt qthvbf tcph tvkvmms rdnvlt hjpv ftzgp sqdsxhb drchk (contains eggs)

2020/src/main/resources/day22.txt

@@ -0,0 +1,53 @@
+Player 1:
+21
+48
+44
+31
+29
+5
+23
+11
+12
+27
+49
+22
+18
+7
+15
+20
+2
+45
+14
+17
+40
+35
+6
+24
+41
+
+Player 2:
+47
+1
+10
+16
+28
+37
+8
+26
+46
+25
+3
+9
+34
+50
+32
+36
+43
+4
+42
+33
+19
+13
+38
+39
+30

2020/src/main/resources/day23.txt

@@ -0,0 +1 @@
+871369452

2020/src/main/resources/day24.txt

@@ -0,0 +1,419 @@
+eeneseeeneeseweeeneswneenwwee
+swswswneswwseenwsenwsweswse
+wswswswnweswnwswswwwswswswweswswswsew
+seswswnweswswswseseseswswswswswswseswse
+nwswswswswseseswseseswswswswseswswsenwsw
+nwnwnwnwnenesenwneneswswwswnenenwnwnw
+ewwwwwswswwwwwnwnewwwwwww
+nwswneewwwsewnwswnwneswnenwnwsenweswnw
+seseseseseseeswsesenweswwseswseseswse
+wwnwwsewenwsww
+nwnwsenwnwenwnwnwnwwwnwnwnwwnwswwnw
+wwwnwwwesewwwwwwwwweww
+swenwwswswswseneneneseswswnwnenwswee
+eseeseseseeeswseeneweneeeseese
+nwswswnwnwswsweeweseswswswseswswsesee
+swswswwseswnenwneneswseseswsweseswswnw
+nwnwnenwnenwnenwneswnw
+eeeweneweeseneeneeeseeeeee
+nenenenwneneneneneneeneneneswnenenenene
+wwenwswwnwsenwwsenenenwnwsw
+nwnewnwnwnwnwnwnenwsenwneewnwnwsenwwse
+swwnewwsenwwswwwwswwswswse
+senwswseseswswseseswseswswsewswseswsesee
+swswweswnwswwswwswwswswswww
+wwwwswwnwwwwwnenwewnwwwnwnww
+wewwweswneswswseseswwnewwsenenw
+senwsesesesesesenwswseseseeseseseseseswse
+seseseswswswswseswseesesesenwse
+swnwswswswsweswseswswswswswswswsw
+wewwenewnwnwwewwweswnwswsww
+wwsenesewwwwwnewswwwwswnwwwsw
+nwsenenenewenwnwnenwnenwnwnwnwnwnwnene
+wenwweswswewnenwswnwswwwsewnesw
+swnwwswneswneeswsesenwseswnwseseneseseswsw
+nesenwnwnenenenwnwnwnenwnwnwnwwnenenenw
+eneswswneeseenenwweeeeweeeee
+swneneneneeneneneweneneneneneneneneseene
+nesenwsewewseswseseseseswseneswnesene
+nwnewewneswwsewwwwsewsewwnew
+eeweeeeeeeeeeeneeeeeswe
+nwswwnwsweswnwnwseewnwnwwneewsew
+neswswsewswswseswsenwswswneseesww
+eenwnwwenwswswswneseseseneeweenwsw
+seseswswseswnwseseswsesewswseseseseneswe
+sewwnwnwswnwnwnwwwnwnwnwewnwwnww
+sewswwswwnwnesewswwswnwesewswwnw
+seswswseseswsenwswseswseswseswseswswesw
+wseneseseswseswseswseswseseseswsesenwsese
+eseeneswwswnwnwse
+swswswswsenwseswswswseesesesw
+wswswswwneswswswswsweswswwswnwwswswsww
+nwnwnwneswneswswnwnwneswnwnenwnwseenwe
+swsesewnwseseseeswswswseseseseseseswsese
+senwsenwnwnwnwnwnwnwnwnwwnwnwnwnewwnwnwnw
+nweeesweeseenweneesenweseswwse
+sesesewseneewseseeeseeeesee
+sweswswswnenwswswswnwseswsewswswwee
+nwwwsewseeseneseesesewseneseenee
+nwnenenenwswneneneneenenenene
+seswwseseseseseseseseseswseesesesesenw
+neneswnwneneenenenwneneswnwnw
+seseseeeswewneneswnwswwsenwesewnee
+swwseswseswwsweswswneswswswseseswsw
+neneewewneneneneeewneeenenesee
+seneeseseeseesenweseseseseseswseseese
+nenwwwwwswswwwwnwwwwwnwewww
+swswswswswswswswnewnwswswswseeswswswsesw
+seseeeseswsesesesesesewsenewsesenwswse
+swswswswswsweswswwswnwnwneswwsweseswsw
+nwsweswnwnwnwnenenwnesenwnwnwnwwnwnwnwwse
+seseseseseseseseesesenwwseeseneseesese
+weneseseeseseswsweseneneneesesweswne
+seseseswseswesesenwsesesesesesesesesewne
+neswnwnwnwnewnewseenwnwswsenwnwnwnwsw
+neswnwnewneswewseeneneneneneeeeenee
+nwnwnwwnwenwwswneww
+nwenwnwswwnwnwwnesenwswnwnwnwnwsenwnwenw
+seseswswswswnwswswswswswnwsweswseseswswswse
+neneenenwneseneneneneseneeneneneenwnene
+ewwnwnwwwwwwwwwww
+nwnenenwneseneneswsenewnenenwsenwnenwnene
+wsesewwnenenwswnwwweewsenwnw
+nwnwsesenwenwnwwwnwwsenwnewnwnenwsesw
+swswwsesesewwneeswseneswwneswneswswne
+enwnwswnweswswnwenwnwnwnwnwnwnwnwnweswnw
+eseeswnwnesewseneeenwsesenwsewswwne
+neswwseneswseweswseswswnwnese
+wwwneswwswwwwswwwnewwwwwww
+nenenwnenenenenwneneswenenwnenene
+neneswnwneswwswnwnesenenenenenwnenwnenenw
+wnenenwsenwnenwnenenwnwnenwnwnwsenenewne
+wnwnwnwnwnwwnwsenwnwnwnwnwnwnwnw
+eswseswswseswswsweswnenwswswswswswswnwsww
+wswwseseseseswseseseseseseswseneseseese
+seeseeeseseseseenwsesesesesenweseesw
+eswnwseswsenwswwnenwswswswnesweswswwsw
+neeseenewneneesw
+nwenenewswseeneswenewswnwseswwwene
+wswwenwwenwseeswnewswsewnwneseswwne
+eseswseesewseseseenwesesese
+nenenenenweneneswnewnenenenenenenenwne
+seseneneeseswwseneseswnwneseseeenwesw
+seeswseeeeswnweeeeenweeweee
+seeeenweseseseesesweenweseneee
+neneewnwneneseneswnesenenwenenwnenesw
+nwnewnwenwnwnwswnenwnwnwnwnwnwnwsenwnwnw
+ewsweswseswswswwewneswwwswesww
+eneeseseeeeseseswwseeseseseeene
+nwsesesewwnwnewnesenwnewwseseenew
+sewswswswseseswswswseswseswswswneeswnwswe
+neswneswnenenenenewnesenwnwnenwneswnenenene
+nwnwnwnwnesenwwnwnwnwnenwnwswnwnwwnwnwnw
+swseseseswswsewneswsenesenwenenwseseese
+neswseseseswseswsesesewsesesesese
+seseeeswnwseeeswseseseesenwseseee
+swneswswswwswsenwswswswseswswswswseswswswsw
+wsenwswwwwswswww
+nwseswseesewseeswsewswnenesenwsew
+nesweeseeweenenenweneswnenenee
+wnwwwnwwwswnewwnwnwwewnwnwnww
+wnwnenwswswnwnwsweesenenweswnewenw
+seeseesenwseseseeeseseeseeseese
+swseswswwswenwswswswswswswnenwswswswswse
+eswseswwwnewwsewwwwwswswenesw
+wnwnwswwnwnwswnwnwnenwwwwnwnwnweeww
+seswwseswnesweswswseseswswseswseswswswse
+nwnenwnwneneneneswneneswnwswnenenwneeneswne
+swwwewswwnwwewwswwswswwswwwsw
+seneenwswwseeseseneewenwseneswnewe
+wwsenesesesenewewnesweseewsesw
+nwwswwwesewwwwwwnwwwwwwwnww
+newwnwwnenwwswsesewswseseewwnwwwsw
+newswswseswswswwswswwswsww
+eeesenweeeenweeesenwseeeenee
+ewenenesewseswseweseeeeseeseese
+eeeeeneeeeeeseeswenwnweeeee
+wwnewnwenewewsewseseneweswswne
+wnwwswneneneneseneseneweseenwneseneee
+swewnwwnwnwneseneewneneneneene
+enwnwseeneeneneeeneneeeneeswnene
+sewswseneswwseeswneswseswnesenw
+nenenwnenenwseneneneneseswnenenenewnene
+eseseseseeeseeseseeseenwsesesenewsw
+newenewnesweeeswneeeseenwnenee
+wswswsenwswswsweswneneswswswswswsesesw
+wsesenwsesesewsesesenesesesesenesese
+eseswswseswswswswnwswswsenenwswseswswsesw
+nwsewsewswswwwnwsenewnwwwwnwew
+seeseeweewwsenwwneneneeswesewne
+nwsweseswseseseswneeseseswnwseswsenesw
+seswswswwneswsesenesewswnenwswswseswwse
+seeseweseseneswnwseseseesweenwsenw
+sweswseswwwswnwswnenwwsewswwnwswsw
+eeeeeeeneswneneeneeswnweenwnese
+nwwwnwnwwwsewnwwswnwnenwnwwwww
+swswseseswswsenwswswswneseseswsewseswswsee
+eseeeseseeseseewsenenwewsese
+wwwwwwwwnwswwnwwewwwwnww
+wneenesesenenwwnenwnwneswsenenweswne
+wswnewwwwwwwwww
+enenwnenenwnwnwnwnwnwwnenw
+nenweswswswnenwnenwseneeswesewnenenew
+neeneneswnenwneswsweeneneeneenwnenene
+sesesesesesesesenwnwesesesenwwesesese
+wswwswswswwnwnwwseswswwswswsew
+nwneseewnwnwnenwnewnenenenwnenwnenwnenw
+neeeneeeneeeneeeneenesweneenew
+seswneswsenwesesesewseswseswsesewsesw
+neswnenesenenwneneneswnenenenenenenenenene
+neswwswswnwswswswswswsesweswswswswswsw
+enwwswnwnwwnwnwnenwnwsenenwnwwnwnwnw
+swnwswwswswswswesweswseseswswseseswsw
+wsenenwsenwnewsenwnwnwsw
+nwnwenwsewwswwnwweswnwsewsewnesew
+nwnwenwnenwnwnwwnwnenwnenwnw
+newneweneneneenenenwnw
+swenesesenesesesesesewseneswsesesesese
+swneneneneseeseeneeseeneewswwwww
+nwnwnwenwnwnwnwwnwwwnwnwnenwnwswnwse
+nwnenwneneswesenwswsewnenwnwnwnenwswese
+seseswswswswsweseseseswnwsesw
+nwenenwneneneneneenenenesweneneswnenene
+nenwwwnwsenwnwnwnwnwsenwnwnwnwnenwnwnwnese
+neneeeeweneeneneswnwnenenwneneswne
+wwwneswnwnwnwwnwnwewnwnwwwwsenew
+eenweeeeeesweeeeeee
+eneweseseeeswewsewseswsenwesenw
+nenenwnenenenwseswsewnenenwneswnw
+nwwwswnwswnwnenwwenwnwnwnenwswnwnwnw
+eswseneeeewenweeseswsewseenee
+wswswnwneseswseseneswsww
+sewwwwwnwwwwwnenwwwwwnwwnw
+enwnwnwwwnwwsenwsewnwwsewswwnwwnw
+swseswenwenewnesweseswnewsenwseswwwsw
+nwswwnwnwnwnwenwnwwnwnwwwnwnwnwnww
+wenwswnenenenenenwne
+swwwnwnwwwwnwewwwwnwnwenwnwnw
+nwswneswneswsenenesenenwnwwnenwnwneene
+neneswneweneneeeweneneeeenenwene
+neenweneswnwneneneneneneneneswnenenwnenene
+wswnwwwwnwwnwweeswnwwnwwwew
+eweneeswneneneeeeeeeeeeew
+seeneeseseseswswsenwnwseneeesweee
+eneeneseenesenenenenenenwwwneeneswse
+swseneenenenenenenesenesenewwnwnenene
+swnenweeeeeneeewswenwenwswewsene
+eswnwnwwnwnwswseewnesenwwnweseww
+nwnewseewnwwwwnwnwswnwnwnwnwnwwnw
+nwnwneenenesenwnenenenenenenwnenwswnew
+swwswnewewwwwwwwwewwnwwwsw
+eeseseseeeeeseenweeeeswe
+nwnwnwweswnwenwnwnwnwnwnwnenwnwnewnw
+swwsweneswsewnwwswswwsweenwsww
+neswneneswseswenenenenenenwnwnwnesw
+wwwnwswwwswneewwwnwnwewwwe
+enesewnwwsesenenewwwwsw
+neneneswnenenenenenesenenenenenenwswnwne
+seswseseswsesweseseswswnwseseswswsesesw
+nwnwnwnwsewwnwwnwwnwwnenwnwnwnwnw
+seeeeeenewneeswneeeenesenwnene
+wwewwwwwwwwwwwwnwsewnw
+seseswseseseneesesewsenese
+sesweseswsesesewwseweeseseseenwsw
+neswseswswwswswseswswswswswwwneswwsw
+ewseneseeneswseeesesw
+swswwnewnwswneswnwwnewsesewswswswwe
+nwnwnwnwnwnenwnwnwnwnwnesenwnw
+swnwewsenwwwwwswsewnwneenwnwwnww
+swswswseseswseseswnwsewswsesesesenesw
+neenenwneneneneneeeeeneeeneeswese
+eneeeneneeneeswswnee
+swnewswwwswswswswswswswswnwseswsenewswsw
+swseswsesweswsewswswseswseseneswswswsww
+swenwnenewswnewwsewnwenwnwswnwswwnew
+swswwwsenwwnwswsewnesewwnwnenene
+weneneeneswnweeweeswweeswnesw
+nwswsenenwesenwnwsenwsewenwswnwnwnwnew
+nesweenwneeeswwneneneeneeneenwenee
+nesesweswswwswswseswswseseswswseseswsw
+eeewswnweesweeeseenenenenewee
+sewwsesesesenenwseneseseseseseesewsesw
+nenewsewnwnwnwneneswnenenenesenwenw
+sewwwwswwsewwwwnwnwwwwwwwsw
+sesewwseseseseseseseseneeseseeeseese
+neneneewwnenenenenenwneneseeesenene
+eseeeneneenweeeeeneeee
+enwswnwwswenwneewswnwswwseseswseenew
+nwnwnwnenwnwnwwnwnwnwnwnwwnwnwnwsenwnw
+seswswswenwnwswswswseenewswneneswwsw
+wswswwwewwnwswswswnwwesewwsww
+seseseeseseseseseeseswseswnesesenwsesese
+swnenwswsewwsewswnwswswswnwneenesee
+nwnwwsenenwnenwnwnwnwwnwnwswnwnwnwnwnw
+senwwswnewwsenewwwsewewwwwwww
+wnwwwwnwsenenewwnwwewwnwwnwsenw
+ewseewsewnwnenewwwwswwneewww
+wnesenweenenweeswwenwesenesenee
+eweneneneneweeeeeneswneneseesw
+nwwsenewwnenwenwswewwwwseswwww
+eewseseeeseeseeseneeseeeeese
+wswwneswnwwnweenwnewwswnwnwwwnwwsw
+nwswsenwwwnwwwwswnwwnwwnwenwwnenw
+wsweswwswswwwwsewweswnwwwswww
+neeeweenwneneeneeeseeeneeeeesw
+swswswseswwswneesewswnwswseseseswsw
+swwwwwnewwwwwwwwww
+ewwwewwwwswneswwwwwnwwwwww
+swwswswswwsesweswswswwwswseswswnewnw
+nenwnwnenwnwnwnwnwnwnwnwnwnwswnenwnesenew
+swswswswweswswswseswswswswswswwswnwsw
+eeseeseeeeseseseseseeseeesenwnw
+seseeseseseseneseseseseseseseseswsewnew
+nwwnwnwswswenwnwnwsenwwswnwnwnwewnwnee
+eeneswswneeeeeeeeeeeeenene
+swswswnwswwswswswneswswswswneseswswswswsw
+nenwnwnenwnwneswnwnwnenwnwnenene
+swnwnwnenewenenwnenwsenenwnwnw
+swswswswswnwwswswswswswnewwswsweswsw
+swswsweswneswswswswwwswseswswswswwsww
+neswnwswsenewnesenwenenenewnwnwnw
+eeeeweewneeeeeeeeeeee
+sewswswseseweeseseseeseswnenwenwsene
+swswsenwswswswswswswseswswswnweswnwesw
+wnesenweeneneneenesenewneeneneene
+nwnwnwnwnwnwwnwnenese
+wweeeneeeeeseseee
+nwnenenwnwwnwnenenwnwnwnwesenenwneseswnw
+eeeswenweseeeeeseeenewnwswe
+enwneeweneeseswsenwnenwseneneneesw
+seseseseseswsesewsewseneneseneneswsesw
+seseseeseesenwseseesenwsweeesewse
+neeeeeneswweewneeeseeeeenee
+swswswwswswswswseswswneswswswwsweswswsw
+swswswseswseswswswswswnewseseseswswswse
+swwwwswswswswnweswswwswne
+wwwnwnwwwwwnewwnwwnwnwnwnwsew
+swswswswswswwwswseswnwneswseswnesw
+nwneseswsenewnweneswsenenenenwnenene
+seseeseseeseenweeseseeswswesesesenwe
+neeneneweenewneneenwnweneseesweee
+eneeseeseeswsweneeseseseesee
+swnenwnwsenwseswsenwseenwswwsesenwsese
+eseseeeeswseeeeenweeeeeee
+eneeneeneeeeswesweeeeneeene
+nwnwewwnwnenewsesenwnwnwnwseesewnww
+swswswswswswseswswnwwswnewswseneswseswsw
+nwnwnwnwnwnwnwnwwnwnwenwnwnwnwnwnwnw
+sewswswswseneesesenweswnwswsesenwseesw
+eneeeseesenwweseeneeweeew
+nenenenenenenenwneneneneneneenewswe
+wwwswwneswwnwenwwnewswnewsesww
+wsewwswwnwwwewwnwnwwweswwse
+nwesenwnwnwnwwsewenwnenesweneswwnwe
+swneswnesweswnwwnenenweeew
+nwnwwnwnwenwnenenwnenwenenewneswsenwnene
+nwnwnenwsenwwnwwnwnwenwwnwnwwnw
+neseseneswwswwseswswsweswseswseseseswsw
+nenenenewsenwseenenewneswsenenewnenenene
+seseseesesesesesesenwswsewseesesesesese
+eneenenenewseseeeneenenwnenenenenenene
+nwswnwswneswwseeswswswseswswswswswsww
+swweswsewswwseseseswswswswseswswee
+nwnenwenewwwnwnwnenenwenwnwesenwne
+wwwwwswswewwswwwwwswsweswww
+swswwnweseenwwnwwwswswwwseseswnwe
+nwnwwnwwwnwenwswwwnewseswnwnwsene
+wwwswwwwwswwseswswswnwneseswwsw
+wwnwnwwwnwnwswenwnwnwnww
+neneeeneswnewneeenenwswee
+newnwnenenenwneneswsenenenenenewsesenenene
+eseseeseseswwnwswsesenwwsenenwseseene
+neneswnenenenwnenwnwne
+wswwseswnenwwwswwwwwwwwswneww
+seewwewwneeewesenwwnenwwnesesw
+neneneneneneeneswnwnenwneneneneswwnwne
+nwnwnenenwnenwnewnwsenenenenenenwneneenw
+nwwnwnwenwnwnwnenwsenwnwnwnwnenwwnwnwe
+swsewwnenenwneneneeneneswneenenenenwswne
+eeneneeenesesweewsweenenenwnwenee
+nenenwneneswseneneneeneeneneneenenene
+wswwwseenenwsenwnesesenwneswnwnwwe
+wseswswswwwswswswnwewswswswswswswswsw
+nwswseswneneneeneswnenwswneneneneenenwe
+sewnenenenenwseswnesenenwsenwnwnenenene
+nwwwnwswwneeeewnwnwswewnwnwsenwe
+seseseeeesewneseesese
+nesenenenenenenenenewneneneseswnenenenew
+nwswswswswwswswswwswswswswswswseswswswne
+wwwwwsewwwnewwwwwwwwww
+nenwnwnwnwneenwnwwnwswnenwswsenesewse
+eeseseswseseeeeeeeeseseenesesenw
+nwnenenwnwnwnwnwsenenwswnenwnenenwnenenwne
+nwwenwnwnwnwnwnenwnenwnwnwnwnwnweswsw
+nenwsenenenenenenenwnewnwenwnenenwne
+nwwnwwnwseneeseseswnwneeeseeneenee
+wewnwnewwnwwwwswwwnwwwseswww
+neswseeseseseseseseswsewnwseswswswswsee
+sewsesesesenwsenwenwwnesesenwnwse
+seeeeneneeeneeeeewwneeeene
+neneewwneeneeeeeneneeeeneeee
+nwsesweswesesesesewswseseswswseswseseswse
+wwnwnwwnwnwnwnwnwwwnenwwnwnwsenww
+wnwsewnesweewsenwwenwnwenwwwse
+wswwwewswwwwwwwswnweww
+swswnwswswswswswnweneswnewneseseswswswne
+weseseenwweeswenwseeenesewsenw
+swswswswseneswswswswswswswneswswswwswswsw
+senenenenwenesenewseenewswneneeene
+swnwswseseseseesesewswseseseseseswnwe
+neswswewwwewnwwwnwswwnwneewwwsw
+swwnewnwweswswnesenwswewseswswseswsww
+eseseweeneweeeeeeeenewsew
+eeseenwsenwswseeesesesenwwsesenwsew
+esweswwseesenenesesenwsesesenwseseee
+senwswnwswnwnwswseswswswseseesw
+nenwneneenenenewnenwnenenenenenenenesene
+seeseeenenwewweesenwweneneeswe
+wwwnewwwwwwwswwwwwwsw
+neseswsenwseseseseseseswseseseswseseesw
+neneeewsewsewenesewnesewsewsew
+wwswwnwnwenwnwwnwwwenwwnwnwnenwse
+nwnwswnwnenwwnwnwswneswenwwwswnwwe
+enenwwneeeeeeeneneeeeeeeeswe
+weeeeswesenwse
+nwnwnewnwsenenenwnwnwsenwnwnwnwnewnwnwenw
+swenesenewwwenenwsewswwwsewnwe
+nwswwnwwnenwnewwsenewwwsewwnwse
+nwnwnwwnwnwwnwsenwnwwwnewnwnwwwnwnese
+seswswwwwwwswswswswswwnewwwww
+neswwseenwwnwswseneeewswnwseneesww
+seesweswenweseenwnwseswwnesenwwnwee
+seseseseneswseseseseseswseseswenenwsese
+seesenesesesenwwseseseseneseseseeww
+eseseeseseeeseseseseeseseewsesene
+wsewwwwwwnenwnwwwwwwnewwnwsw
+eseswesenwseseeseeeeseseseeesee
+neneneseeneneenewneneneneneene
+neeseseseseeseseswseeee
+seeeesesesweeesewseneseeesesee
+enwweeeeeeeeeseeeeeeesee
+wwwseswsewnewwnenewswswswswswwsww
+seeewnweseswenenenweeeenee
+nwsenwwwwnwnwswnwwwne
+wesesewswswneeenwnweneenweneseesw
+eeswswwnwswnwnwnwnwesenwwnwnwwnenwnw
+nweenwseseneeenwseneenwneswneenee
+nwsenwsenwnwnwnwnwwwnwnwnwnwnwnewnwne
+seesewseeseseneseseseswsesesesenesese
+swwseswnwwwswwswwswwew
+enwneenenenewnewsenenenenenenesenene
+swwswswwwwwwswneswwswwseswwsene
+neenenenwnesweneewswne
+nwnwwnesenwnwnwnwnenenenenenwnwnwnenwne
+neeenesewwnwsenwswseseeseneswsewsesw
+newwnwswswnewswwswwswswwwsewww
+wsewwneenwwww
+wswwnewwwwwwwwww
+wwwwswwwswwnwswewwwswswwww
+swseswswswswseseseswseeswswsenwsesw

2020/src/main/resources/day25.txt

@@ -0,0 +1,2 @@
+1327981
+2822615

2020/src/main/resources/simplelogger.properties

@@ -0,0 +1,6 @@
+org.slf4j.simpleLogger.logFile=System.out
+org.slf4j.simpleLogger.showDateTime=true
+org.slf4j.simpleLogger.dateTimeFormat=yyyy-MM-dd HH:mm:ss:SSS Z
+org.slf4j.simpleLogger.defaultLogLevel=info
+org.slf4j.simpleLogger.log.io.micronaut=info
+org.slf4j.simpleLogger.log.io.micronaut.context.lifecycle=info

2020/src/test/kotlin/Day01Test.kt

@@ -1,13 +1,12 @@
 package be.vandewalleh.aoc.days
 
-import io.micronaut.context.BeanContext
-import io.micronaut.context.getBean
+import be.vandewalleh.aoc.utils.factory.createDay
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 
 class Day01Test {
 
-    private val day = BeanContext.run().getBean<Day01>()
+    private val day = createDay<Day01>()
 
     @Test
     fun `part1 result`() {

2020/src/test/kotlin/Day03Test.kt

@@ -1,8 +1,8 @@
 package be.vandewalleh.aoc.days
 
-import be.vandewalleh.aoc.utils.input.Input
-import be.vandewalleh.aoc.utils.input.createDay
+import be.vandewalleh.aoc.utils.factory.createDay
 import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 
@@ -22,7 +22,7 @@ class Day03Test {
             "#.##...#...",
             "#...##....#",
             ".#..#...#.#",
-        ).let { Input(it) }
+        )
 
         private val day03 = Day03(example)
 
@@ -43,11 +43,13 @@ class Day03Test {
         private val day03 = createDay<Day03>()
 
         @Test
+        @Disabled
         fun `part1 result`() {
             assertThat(day03.part1()).isEqualTo(294)
         }
 
         @Test
+        @Disabled
         fun `part2 result`() {
             assertThat(day03.part2()).isEqualTo(5774564250)
         }

2020/src/test/kotlin/Day04Test.kt

@@ -1,7 +1,6 @@
 package be.vandewalleh.aoc.days
 
-import be.vandewalleh.aoc.utils.input.Input
-import be.vandewalleh.aoc.utils.input.createDay
+import be.vandewalleh.aoc.utils.factory.createDay
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Nested
@@ -26,7 +25,6 @@ class Day04Test {
             hcl:#cfa07d eyr:2025 pid:166559648
             iyr:2011 ecl:brn hgt:59in
         """.trimIndent()
-            .let { Input(it) }
 
         private val day04 = Day04(example)
 
@@ -63,7 +61,7 @@ class Day04Test {
                 hgt:59cm ecl:zzz
                 eyr:2038 hcl:74454a iyr:2023
                 pid:3556412378 byr:2007
-            """.trimIndent().let { Input(it) }
+            """.trimIndent()
 
             assertThat(Day04(input).part2()).isEqualTo(0)
         }
@@ -83,7 +81,7 @@ class Day04Test {
                 eyr:2022
 
                 iyr:2010 hgt:158cm hcl:#b6652a ecl:blu byr:1944 eyr:2021 pid:093154719
-            """.trimIndent().let { Input(it) }
+            """.trimIndent()
 
             assertThat(Day04(input).part2()).isEqualTo(4)
         }

2020/src/test/kotlin/Day05Test.kt

@@ -1,6 +1,6 @@
 package be.vandewalleh.aoc.days
 
-import be.vandewalleh.aoc.utils.input.createDay
+import be.vandewalleh.aoc.utils.factory.createDay
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 

2020/src/test/kotlin/Day13Test.kt

@@ -0,0 +1,26 @@
+package be.vandewalleh.aoc.days
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+class Day13Test {
+
+    @CsvSource(
+        value = [
+            "           7,13 | 77",
+            "     17,x,13,19 | 3417",
+            "     67,7,59,61 | 754018",
+            "   67,x,7,59,61 | 779210",
+            "   67,7,x,59,61 | 1261476",
+            "1789,37,47,1889 | 1202161486",
+        ],
+        delimiter = '|'
+    )
+    @ParameterizedTest
+    fun examples(buses: String, answer: Long) {
+        val input = listOf("", buses)
+        assertThat(Day13(input).part2()).isEqualTo(answer)
+    }
+
+}

2020/src/test/kotlin/Day14Benchmark.kt

@@ -0,0 +1,112 @@
+package be.vandewalleh.aoc.days
+
+import java.util.concurrent.TimeUnit
+import kotlin.math.pow
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import org.openjdk.jmh.runner.Runner
+import org.openjdk.jmh.runner.options.Options
+import org.openjdk.jmh.runner.options.OptionsBuilder
+
+/*
+Benchmark                       Mode  Cnt  Score   Error  Units
+Day14Benchmark.charArrays       avgt    5  0.038 ± 0.001  ms/op
+Day14Benchmark.countReplacePad  avgt    5  0.044 ± 0.002  ms/op
+Day14Benchmark.stringBuilders   avgt    5  0.082 ± 0.005  ms/op
+*/
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+open class Day14Benchmark {
+
+    private val mask = "1XX10X10100X1010X1000100X0X10X001X00"
+    private val address = 43398.toString(2).padStart(36, '0')
+
+    @Benchmark
+    fun stringBuilders(blackhole: Blackhole) {
+        val mutationCount = mask.count { it == 'X' }.let { 2.0.pow(it.toDouble()).toInt() }
+        val mutations = Array(mutationCount) { StringBuilder(36) }
+
+        var groups = 1
+
+        for (i in mask.indices) {
+            when (mask[i]) {
+                'X' -> {
+                    groups *= 2
+                    val groupSize = mutationCount / groups
+                    var currentChar = '1'
+                    for (b in mutations.indices) {
+                        val builder = mutations[b]
+                        val flip = b % groupSize == 0
+                        if (flip) currentChar = if (currentChar == '0') '1' else '0'
+                        builder.append(currentChar)
+                    }
+                }
+                '1' -> mutations.forEach { it.append('1') }
+                else -> mutations.forEach { it.append(address[i]) }
+            }
+        }
+        blackhole.consume(mutations)
+    }
+
+    @Benchmark
+    fun charArrays(blackhole: Blackhole) {
+        val mutationCount = mask.count { it == 'X' }.let { 2.0.pow(it.toDouble()).toInt() }
+        val mutations = Array(mutationCount) { CharArray(36) }
+
+        var groups = 1
+
+        for (i in mask.indices) {
+            when (mask[i]) {
+                'X' -> {
+                    groups *= 2
+                    val groupSize = mutationCount / groups
+                    var currentChar = '1'
+                    for (b in mutations.indices) {
+                        val builder = mutations[b]
+                        val flip = b % groupSize == 0
+                        if (flip) currentChar = if (currentChar == '0') '1' else '0'
+                        builder[i] = currentChar
+                    }
+                }
+                '1' -> mutations.forEach { it[i] = '1' }
+                else -> mutations.forEach { it[i] = address[i] }
+            }
+        }
+        blackhole.consume(mutations)
+    }
+
+    @Benchmark
+    fun countReplacePad(blackhole: Blackhole) {
+        val bitCount = mask.count { it == 'X' }
+        val mutationCount = bitCount.let { 2.0.pow(it.toDouble()).toInt() }
+
+        val results = Array(mutationCount) { CharArray(36) }
+
+        repeat(mutationCount) { i ->
+            var count = 0
+            val result = results[i]
+            val currentMask = i.toString(2).padStart(bitCount, '0')
+            for (j in address.indices) {
+                result[j] = when (mask[j]) {
+                    'X' -> currentMask[count++]
+                    '1' -> '1'
+                    else -> address[j]
+                }
+            }
+        }
+        blackhole.consume(results)
+    }
+}
+
+fun main() {
+    val opt: Options = OptionsBuilder()
+        .include(Day14Benchmark::class.java.simpleName)
+        .forks(1)
+        .build()
+
+    Runner(opt).run()
+}

2020/src/test/kotlin/Day16Benchmark.kt

@@ -0,0 +1,39 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.factory.createDay
+import java.util.concurrent.TimeUnit
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import org.openjdk.jmh.runner.Runner
+import org.openjdk.jmh.runner.options.Options
+import org.openjdk.jmh.runner.options.OptionsBuilder
+
+/*
+Benchmark             Mode  Cnt  Score   Error  Units
+Day16Benchmark.part2  avgt    5  0.697 ± 0.026  ms/op
+*/
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 3)
+@Measurement(iterations = 5)
+open class Day16Benchmark {
+
+    private val day16 = createDay<Day16>()
+
+    @Benchmark
+    fun part2(blackhole: Blackhole) {
+        blackhole.consume(day16.part2())
+    }
+}
+
+
+fun main() {
+    val opt: Options = OptionsBuilder()
+        .include(Day16Benchmark::class.simpleName)
+        .forks(1)
+        .build()
+
+    Runner(opt).run()
+}

2020/src/test/kotlin/Day18Benchmark.kt

@@ -0,0 +1,44 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.factory.createDay
+import java.util.concurrent.TimeUnit
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import org.openjdk.jmh.runner.Runner
+import org.openjdk.jmh.runner.options.OptionsBuilder
+
+/*
+Benchmark             Mode  Cnt  Score   Error  Units
+Day18Benchmark.part1  avgt    3  0.253 ± 0.098  ms/op
+Day18Benchmark.part2  avgt    3  0.283 ± 0.027  ms/op
+*/
+
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@Warmup(iterations = 1)
+@Measurement(iterations = 3)
+open class Day18Benchmark {
+
+    private val day18 = createDay<Day18>()
+
+    @Benchmark
+    fun part1(blackhole: Blackhole) {
+        blackhole.consume(day18.part1())
+    }
+
+    @Benchmark
+    fun part2(blackhole: Blackhole) {
+        blackhole.consume(day18.part2())
+    }
+
+}
+
+fun main() {
+    val opt = OptionsBuilder()
+        .include(Day18Benchmark::class.simpleName)
+        .forks(1)
+        .build()
+
+    Runner(opt).run()
+}

2020/src/test/kotlin/Day18Test.kt

@@ -0,0 +1,22 @@
+package be.vandewalleh.aoc.days
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.CsvSource
+
+class Day18Test {
+
+    @CsvSource(value = [
+        "1 + 2 * 3 + 4 * 5 + 6 , 231",
+        "1 + (2 * 3) + (4 * (5 + 6)) , 51",
+        "2 * 3 + (4 * 5) , 46",
+        "5 + (8 * 3 + 9 + 3 * 4 * 3) , 1445", // !!!
+        "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4)) , 669060",
+        "((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2 , 23340"
+    ])
+    @ParameterizedTest
+    fun examplesPart2(input: String, output: Long) {
+        val day18 = Day18(listOf(input))
+        assertThat(day18.part2()).isEqualTo(output)
+    }
+}

2021/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+    id("aoc")
+}
+
+application {
+    mainClass.set("be.vandewalleh.aoc.days.MainKt")
+}

2021/nim/17/example.txt

@@ -0,0 +1 @@
+target area: x=20..30, y=-10..-5

2021/nim/17/input.txt

@@ -0,0 +1 @@
+target area: x=139..187, y=-148..-89

2021/nim/17/main.nim

@@ -0,0 +1,42 @@
+import nre, strutils
+
+let
+    regex = re"x=(-?\d+)..(-?\d+), y=(-?\d+)..(-?\d+)"
+    data = readFile("input.txt")
+    captures = data.find(regex).get.captures
+    x1 = captures[0].parseInt()
+    x2 = captures[1].parseInt()
+    y1 = captures[2].parseInt()
+    y2 = captures[3].parseInt()
+    minX = min(x1, x2)
+    maxX = max(x1, x2)
+    minY = min(y1, y2)
+    maxY = max(y1, y2)
+
+proc land(dx: int, dy: int): int =
+    var dx = dx
+    var dy = dy
+    var x = 0
+    var y = 0
+    var high = y
+    while x < maxX and y > minY:
+        x += dx
+        y += dy
+        if dx > 0: dx -= 1
+        elif dx < 0: dx += 1
+        dy -= 1
+        high = max(high, y)
+        if x in minX..maxX and y in minY..maxY:
+            return high
+    return -1
+
+var high = 0
+var match = 0
+for x in -1000..1000:
+    for y in -1000..1000:
+        let res = land(x, y)
+        if res != -1: match += 1
+        high = max(res, high)
+
+echo(high)
+echo(match)

2021/src/main/kotlin/Counter.kt

@@ -0,0 +1,29 @@
+package be.vandewalleh.aoc.days
+
+class Counter<K> : Iterable<Map.Entry<K, Long>> {
+    private val map = HashMap<K, Long>()
+    operator fun get(key: K) = map[key] ?: 0L
+
+    operator fun set(key: K, count: Long) {
+        map[key] = count
+    }
+
+    operator fun set(key: K, count: Int) {
+        if (count == 0)
+            map.remove(key)
+        else
+            map[key] = count.toLong()
+    }
+
+    fun toMap() = map.toMap(HashMap())
+    override fun toString() = map.toString()
+
+    fun minValue() = map.minOf { it.value }
+    fun maxValue() = map.maxOf { it.value }
+
+    override fun iterator() = toMap().iterator()
+
+    companion object
+}
+
+operator fun <T> Counter.Companion.invoke(items: Iterable<T>) = Counter<T>().apply { items.forEach { this[it] += 1 } }

2021/src/main/kotlin/Day01.kt

@@ -0,0 +1,27 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day01 : BaseDay() {
+    private val items by lazy { input.lines.ints }
+
+    override fun part1(): Int {
+        var count = 0
+        for (i in 0 until items.size - 1) {
+            if (items[i] < items[i + 1]) count++
+        }
+        return count
+    }
+
+    override fun part2(): Int {
+        var count = 0
+        for (i in 0 until items.size - 3) {
+            val a = items.drop(i).take(3).sum()
+            val b = items.drop(i + 1).take(3).sum()
+            if (b > a) count++
+        }
+        return count
+    }
+}

2021/src/main/kotlin/Day02.kt

@@ -0,0 +1,40 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day02 : BaseDay() {
+    private val lines by lazy { input.lines.value.map { it.split(' ').let { it[0] to it[1].toInt() } } }
+
+    override fun part1(): Int {
+        var horizontalPosition = 0
+        var depth = 0
+        lines.forEach { (direction, value) ->
+            when (direction) {
+                "forward" -> horizontalPosition += value
+                "down" -> depth += value
+                "up" -> depth -= value
+            }
+        }
+        return horizontalPosition * depth
+    }
+
+    override fun part2(): Any {
+        var horizontalPosition = 0
+        var depth = 0
+        var aim = 0
+        lines.forEach { (direction, value) ->
+            when (direction) {
+                "forward" -> {
+                    horizontalPosition += value
+                    depth += aim * value
+                }
+                "down" -> aim += value
+                "up" -> aim -= value
+            }
+        }
+        return horizontalPosition * depth
+    }
+
+}

2021/src/main/kotlin/Day03.kt

@@ -0,0 +1,36 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day03 : BaseDay() {
+    override fun part1(): Int {
+        val moreOnes = input.lines.value[0].indices
+            .map { i -> input.lines.value.map { it[i] } }
+            .map { it.count { it == '1' } >= it.size / 2 }
+
+        val gamma = moreOnes.joinToString("") { if (it) "1" else "0" }.toInt(radix = 2)
+        val epsilon = moreOnes.joinToString("") { if (!it) "1" else "0" }.toInt(radix = 2)
+        return gamma * epsilon
+    }
+
+    override fun part2(): Any {
+        val o2 = findNumber(input.lines.value) { ones, zeros -> if (ones >= zeros) '1' else '0' }
+        val co2 = findNumber(input.lines.value) { ones, zeros -> if (zeros <= ones) '0' else '1' }
+        return o2 * co2
+    }
+
+    private fun findNumber(input: List<String>, keep: (Int, Int) -> Char): Int {
+        var numbers = input
+        for (i in this.input.lines.value[0].indices) {
+            if (numbers.size == 1) break
+            val eachCount = numbers.map { it[i] }.groupingBy { it }.eachCount()
+            val ones = eachCount['1'] ?: 0
+            val zeros = eachCount['0'] ?: 0
+            val maj = keep(ones, zeros)
+            numbers = numbers.filter { it[i] == maj }
+        }
+        return numbers[0].toInt(2)
+    }
+}

2021/src/main/kotlin/Day04.kt

@@ -0,0 +1,33 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day04 : BaseDay() {
+    private val numbers by lazy { input.lines.value[0].split(',').map { it.toInt() } }
+    private val boards by lazy {
+        input.text.split("\n\n")
+            .drop(1)
+            .map { it.lines().map { it.trim().split("\\s+".toRegex()).map { it.toInt() } } }
+    }
+
+    private val results by lazy { boards.map { playBoard(it) } }
+
+    override fun part1() = results.minByOrNull { it.first }!!.second
+    override fun part2() = results.maxByOrNull { it.first }!!.second
+
+    private fun playBoard(board: List<List<Int>>): Pair<Int, Int> {
+        for (round in numbers.indices) {
+            val usedNumbers = numbers.take(round)
+            for (line in board + board[0].indices.map { col -> board.map { it[col] } }) {
+                if (usedNumbers.containsAll(line)) {
+                    val unmarkedNumbers = board.flatten().toMutableSet().also { it.removeAll(usedNumbers) }
+                    return round to unmarkedNumbers.sum() * usedNumbers.last()
+                }
+            }
+        }
+        error("No wins")
+    }
+
+}

2021/src/main/kotlin/Day05.kt

@@ -0,0 +1,50 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day05 : BaseDay() {
+
+    data class Point(val x: Int, val y: Int)
+
+    private val re = "(\\d+),(\\d+) -> (\\d+),(\\d+)".toRegex()
+
+    private fun path(start: Point, end: Point): Sequence<Point> {
+        val dx = end.x.compareTo(start.x)
+        val dy = end.y.compareTo(start.y)
+        return generateSequence(start) {
+            if (it == end) null
+            else Point(it.x + dx, it.y + dy)
+        }
+    }
+
+    override fun part1(): Int {
+        val visited = HashMap<Point, Int>()
+        input.lines.value
+            .map {
+                re.find(it)!!.destructured.let { (x1, y1, x2, y2) ->
+                    Point(x1.toInt(), y1.toInt()) to Point(x2.toInt(), y2.toInt())
+                }
+            }
+            .filter { (start, end) -> start.x == end.x || start.y == end.y }
+            .flatMap { (start, end) -> path(start, end) }
+            .forEach { visited.compute(it) { _, value -> (value ?: 0) + 1 } }
+
+        return visited.values.count { it >= 2 }
+    }
+
+    override fun part2(): Int {
+        val visited = HashMap<Point, Int>()
+        input.lines.value
+            .map {
+                re.find(it)!!.destructured.let { (x1, y1, x2, y2) ->
+                    Point(x1.toInt(), y1.toInt()) to Point(x2.toInt(), y2.toInt())
+                }
+            }
+            .flatMap { (start, end) -> path(start, end) }
+            .forEach { visited.compute(it) { _, value -> (value ?: 0) + 1 } }
+
+        return visited.values.count { it >= 2 }
+    }
+}

2021/src/main/kotlin/Day06.kt

@@ -0,0 +1,27 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day06 : BaseDay() {
+    override fun part1() = run(80)
+    override fun part2() = run(256)
+
+    private fun run(days: Int): Long {
+        var fish = LongArray(9)
+        input.csv.ints.forEach { fish[it] = fish[it] + 1 }
+
+        var newFish: LongArray
+        for (day in 1..days) {
+            newFish = LongArray(9)
+            for (timer in 8 downTo 1) {
+                newFish[timer - 1] = fish[timer]
+            }
+            newFish[8] = fish[0]
+            newFish[6] = fish[0] + newFish[6]
+            fish = newFish
+        }
+        return fish.sum()
+    }
+}

2021/src/main/kotlin/Day07.kt

@@ -0,0 +1,28 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+import kotlin.math.abs
+
+@Day
+class Day07 : BaseDay() {
+
+    override fun part1(): Any {
+        val ints = input.csv.ints
+        return (ints.minOrNull()!!..ints.maxOrNull()!!).minOf { target -> ints.sumOf { abs(it - target) } }
+    }
+
+    private fun calc(position: Int, target: Int): Int {
+        val diff = abs(position - target)
+        var sum = 0
+        for (i in 1..diff) {
+            sum += diff - i + 1
+        }
+        return sum
+    }
+
+    override fun part2(): Any {
+        val ints = input.csv.ints
+        return (ints.minOrNull()!!..ints.maxOrNull()!!).minOf { target -> ints.sumOf { calc(it, target) } }
+    }
+}

2021/src/main/kotlin/Day08.kt

@@ -0,0 +1,49 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day08 : BaseDay() {
+
+    override fun part1() = input.lines.value
+        .map { it.split(" | ")[1].split(" ") }
+        .sumOf { it.count { it.length in setOf(2, 3, 4, 7) } }
+
+    override fun part2() = input.lines.value
+        .map { it.split(" | ").map { it.split(" ") } }
+        .sumOf { (pattern, digits) ->
+            val patterns = decodePatterns(pattern)
+            digits.map { patterns[it.sortChars()] }.joinToString("").toInt()
+        }
+
+    private fun decodePatterns(patterns: List<String>): Map<String, Int> {
+        val result = Array(10) { "" }
+
+        result[1] = patterns.single { it.length == 2 }
+        result[7] = patterns.single { it.length == 3 }
+        result[4] = patterns.single { it.length == 4 }
+        result[8] = patterns.single { it.length == 7 }
+
+        val frequency = patterns.flatMap { it.toCharArray().toList() }.groupBy { it }.mapValues { it.value.size }
+        val a = (result.letters(7) - result.letters(1)).first()
+        val b = frequency.findKey { it.value == 6 }
+        val c = frequency.findKey { it.value == 8 && it.key != a }
+        val d = frequency.findKey { it.value == 7 && it.key in result.letters(4) }
+        val e = frequency.findKey { it.value == 4 }
+        val f = frequency.findKey { it.value == 9 }
+
+        result[0] = patterns.find { it.length == 6 && d !in it }!!
+        result[2] = patterns.find { it.length == 5 && b !in it && f !in it }!!
+        result[3] = patterns.find { it.length == 5 && b !in it && e !in it }!!
+        result[5] = patterns.find { it.length == 5 && c !in it && e !in it }!!
+        result[6] = patterns.find { it.length == 6 && c !in it }!!
+        result[9] = patterns.find { it.length == 6 && e !in it }!!
+
+        return result.mapIndexed { index, value -> value.sortChars() to index }.toMap()
+    }
+
+    private fun Array<String>.letters(number: Int) = this[number].toCharArray().toSet()
+    private fun <K, V> Map<K, V>.findKey(predicate: (Map.Entry<K, V>) -> Boolean) = entries.find(predicate)!!.key
+    private fun String.sortChars() = toCharArray().sorted().joinToString("")
+}

2021/src/main/kotlin/Day09.kt

@@ -0,0 +1,36 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+private data class Point(val x: Int, val y: Int)
+private fun Point.adjacents() = listOf(copy(y = y - 1), copy(x = x + 1), copy(y = y + 1), copy(x = x - 1))
+
+@Day
+class Day09 : BaseDay() {
+
+    private val map by lazy {
+        input.lines.value.flatMapIndexed { y, line ->
+            line.mapIndexed { x, value -> Point(x, y) to value.digitToInt() }
+        }.filterNot { it.second == 9 }.toMap()
+    }
+
+    private val lows by lazy {
+        map.keys.filter { point -> point.adjacents().mapNotNull { map[it] }.all { it > map[point]!! } }
+    }
+
+    override fun part1() = lows.sumOf { map[it]!! + 1 }
+
+    override fun part2() = lows.map { low ->
+        val visited = HashSet<Point>().apply { add(low) }
+        generateSequence(hashSetOf(low)) {
+            it.asSequence()
+                .flatMap { it.adjacents() }
+                .filter { it in map }
+                .filterNot { it in visited }
+                .toHashSet()
+                .also { visited.addAll(it) }
+                .ifEmpty { null }
+        }.flatten().count()
+    }.sorted().takeLast(3).fold(1) { a, b -> a * b }
+}

2021/src/main/kotlin/Day10.kt

@@ -0,0 +1,56 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day10 : BaseDay() {
+    private val chunks = mapOf(
+        ')' to '(',
+        ']' to '[',
+        '>' to '<',
+        '}' to '{',
+    )
+
+    override fun part1(): Any {
+        val points = mapOf(
+            ')' to 3,
+            ']' to 57,
+            '}' to 1197,
+            '>' to 25137,
+        )
+        return input.lines.value.sumOf { line ->
+            val stack = mutableListOf<Char>()
+            for (char in line) {
+                if (char in chunks) {
+                    if (stack.last() == chunks[char]!!) stack.removeLast()
+                    else return@sumOf points[char]!!
+                } else {
+                    stack.add(char)
+                }
+            }
+            0
+        }
+    }
+
+    override fun part2(): Any {
+        val points = mapOf(
+            '(' to 1,
+            '[' to 2,
+            '{' to 3,
+            '<' to 4,
+        )
+        return input.lines.value.mapNotNull { line ->
+            val stack = mutableListOf<Char>()
+            for (char in line) {
+                if (char in chunks) {
+                    if (stack.last() == chunks[char]!!) stack.removeLast()
+                    else return@mapNotNull null
+                } else {
+                    stack.add(char)
+                }
+            }
+            stack.foldRight(0L) { char, score -> score * 5 + points[char]!! }
+        }.sorted().let { it[it.size / 2] }
+    }
+}

2021/src/main/kotlin/Day11.kt

@@ -0,0 +1,63 @@
+package be.vandewalleh.aoc.days
+
+import be.vandewalleh.aoc.utils.BaseDay
+import be.vandewalleh.aoc.utils.input.Day
+
+@Day
+class Day11 : BaseDay() {
+
+    private data class Point(val x: Int, val y: Int) {
+        fun adjacents() = listOf(
+            copy(y = y - 1),
+            copy(x = x + 1),
+            copy(y = y + 1),
+            copy(x = x - 1),
+            copy(y = y - 1, x = x - 1),
+            copy(x = x + 1, y = y + 1),
+            copy(y = y + 1, x = x - 1),
+            copy(x = x + 1, y = y - 1),
+        )
+    }
+
+    private val map by lazy {
+        input.lines.value.flatMapIndexed { y, line ->
+            line.mapIndexed { x, value -> Point(x, y) to value.digitToInt() }
+        }.toMap()
+    }
+
+    override fun part1(): Int {
+        val map = map.toMap(HashMap())
+        var count = 0
+        repeat(100) { count += step(map) }
+        return count
+    }
+
+    private fun step(map: HashMap<Point, Int>): Int {
+        map.keys.forEach { map[it] = map[it]!! + 1 }
+        val flashed = hashSetOf<Point>()
+        while (true) {
+            val count = map.entries.asSequence()
+                .filter { it.value > 9 }
+                .filter { it.key !in flashed }
+                .onEach { flashed += it.key }
+                .flatMap { it.key.adjacents() }
+                .filter { it in map }
+                .onEach { map[it] = map[it]!! + 1 }
+                .count()
+
+            if (count == 0) break
+        }
+
+        map.entries.filter { it.value > 9 }
+            .map { it.key }
+            .forEach { map[it] = 0 }
+
+        return flashed.size
+    }
+
+    override fun part2(): Int {
+        val map = map.toMap(HashMap())
+        repeat(10000) { if (step(map) == map.size) return it + 1 }
+        return -1
+    }
+}