[TASK] Solved Day 23 Pt 1

[TASK] Solved day 21
[WIP] Still working on day 20
2020-12-29 22:19:21 +01:00 · 2020-12-28 21:33:20 +01:00 · 2020-12-28 19:54:43 +01:00 · 2020-12-22 10:54:06 +01:00 · 2020-12-21 13:57:35 +01:00 · 2020-12-19 20:07:56 +01:00
42 changed files with 6426 additions and 32 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6,7 +6,6 @@ version = "0.1.0"
 dependencies = [
 "lazy_static",
 "regex",
- "usize_cast",
 ]

 [[package]]
@@ -56,9 +55,3 @@ checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14"
 dependencies = [
 "lazy_static",
 ]
-
-[[package]]
-name = "usize_cast"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "810f3a98a85147e3ad2a1331aa6dac66490e802d65fa0ab283c383058e3f9751"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,5 +8,4 @@ edition = "2018"

 [dependencies]
 regex = "1"
-lazy_static = "1.4.0"
-usize_cast = "1.0.0"
+lazy_static = "1.4.0"
--- a/input/day12.txt
+++ b/input/day12.txt
@@ -0,0 +1,795 @@
+N5
+W1
+F61
+W2
+R90
+F50
+N2
+F40
+E4
+F48
+R180
+F17
+W4
+N5
+F3
+W3
+F1
+R90
+S2
+F23
+L90
+S3
+W3
+S4
+E4
+L90
+W3
+S3
+E4
+N2
+F28
+S2
+W2
+L180
+E3
+R90
+E3
+F83
+W5
+S4
+W3
+N2
+W5
+F90
+N2
+F82
+N2
+F2
+S4
+L90
+N3
+L90
+S2
+F12
+S3
+F40
+L90
+F56
+N1
+F29
+W2
+S2
+R270
+S4
+F14
+E4
+R90
+E2
+S2
+E2
+F82
+L90
+N3
+R180
+R90
+S1
+W1
+L90
+S2
+F78
+W2
+F52
+N4
+W5
+F38
+L90
+W2
+S2
+L90
+F66
+R90
+F62
+E3
+S5
+L90
+F99
+F2
+E4
+R90
+N3
+W4
+N1
+F71
+E2
+N3
+N2
+R90
+E2
+F66
+S4
+R90
+E5
+F29
+E5
+L90
+W2
+N2
+E3
+F18
+L180
+F17
+W1
+R90
+W3
+S5
+R90
+S3
+R180
+N5
+F69
+W1
+W3
+L180
+F72
+W5
+N1
+R180
+W3
+W4
+F85
+W4
+L90
+E4
+N5
+F73
+R90
+F70
+E4
+F79
+S5
+R180
+E2
+F35
+E4
+L270
+W2
+L90
+N5
+R90
+N4
+F64
+W2
+R270
+F33
+N5
+E4
+F94
+W1
+N1
+R90
+F79
+F46
+E1
+R180
+S3
+W3
+F72
+E1
+W4
+F95
+W2
+L90
+N3
+L90
+F85
+W3
+W1
+F54
+N3
+E1
+N4
+E5
+L90
+F61
+W2
+F7
+L180
+F87
+N4
+W1
+F87
+F3
+E3
+F63
+R90
+S4
+R180
+S4
+R180
+R90
+R90
+E5
+N4
+E2
+F86
+S3
+F98
+N4
+F70
+L90
+E4
+F26
+W4
+F19
+L90
+S4
+W4
+F84
+N1
+E4
+L180
+S2
+F74
+S1
+F86
+R90
+S2
+F78
+N4
+S2
+W1
+N5
+E2
+F38
+W4
+N1
+F75
+S1
+E1
+N3
+S1
+F54
+N3
+F88
+N5
+L180
+F15
+S2
+S2
+E2
+N3
+F97
+S3
+N3
+E3
+N5
+E3
+R90
+F87
+L90
+F15
+L90
+E5
+R90
+F70
+N3
+W2
+F47
+W2
+W3
+F17
+R90
+F95
+E4
+F28
+W4
+R90
+E2
+R180
+N4
+R180
+W4
+R270
+F73
+W1
+N2
+L90
+S1
+F65
+E1
+F42
+N2
+F74
+R90
+F21
+W5
+S1
+N5
+R90
+E4
+N5
+S5
+F99
+W4
+L180
+W1
+F83
+N2
+W2
+F87
+E2
+S3
+W1
+L180
+F89
+S1
+W2
+E2
+L90
+S2
+W1
+S5
+R180
+E5
+N1
+F82
+S3
+F7
+L90
+F31
+L90
+N3
+F84
+W3
+N4
+F100
+N1
+E2
+R90
+F90
+N3
+F43
+R90
+F2
+W4
+L90
+F87
+L90
+E3
+F71
+L180
+N1
+L90
+E4
+N3
+F31
+W1
+F80
+R270
+N1
+E4
+N1
+F22
+N4
+E1
+F57
+R90
+N3
+W2
+L180
+N3
+L180
+W4
+F59
+S4
+F10
+N5
+L90
+S3
+L90
+E1
+F96
+E4
+N3
+F54
+L180
+F47
+W1
+N4
+E1
+S4
+R180
+L90
+N1
+R90
+N3
+R90
+N4
+R90
+S3
+F59
+N5
+L90
+E4
+F72
+W4
+F76
+R90
+E3
+F70
+L180
+N3
+W2
+R90
+F65
+L90
+F71
+S3
+F43
+R90
+W2
+N2
+R90
+W1
+R90
+S4
+R180
+S1
+E3
+F72
+L90
+F61
+L90
+F75
+S1
+S5
+F15
+R90
+E3
+N2
+L270
+F48
+N1
+R180
+W2
+F69
+E4
+R90
+R90
+W1
+S5
+W5
+R90
+S4
+S3
+F51
+F43
+E2
+N5
+L180
+F89
+W1
+R90
+F59
+R90
+E2
+F51
+R90
+F91
+W4
+S5
+E4
+L90
+S5
+R90
+F44
+F47
+E4
+W1
+F77
+S5
+R90
+N2
+F87
+N4
+R90
+W5
+R90
+W5
+F89
+L90
+F61
+E2
+F29
+N4
+R90
+F31
+S1
+L90
+E5
+N2
+F7
+L180
+S4
+F63
+W4
+N5
+S2
+N1
+E5
+F87
+S5
+R180
+F14
+W4
+R180
+E1
+L90
+F67
+E2
+L90
+E5
+S2
+L90
+W2
+R90
+F94
+W4
+R90
+W3
+S3
+R90
+N5
+F55
+L90
+F43
+L90
+N5
+F16
+E4
+N2
+L270
+W3
+E1
+N2
+R180
+F51
+N5
+N1
+F36
+W4
+F38
+N5
+W1
+F29
+R180
+L90
+N1
+W3
+E1
+F78
+E1
+N1
+E2
+F57
+E4
+F83
+W5
+F32
+N3
+W4
+F36
+N2
+E3
+F74
+N4
+F54
+W5
+L90
+S1
+F42
+W4
+S5
+E3
+F64
+W2
+R180
+S2
+E1
+N2
+R90
+W3
+F36
+N3
+R90
+S2
+F53
+W2
+F85
+E5
+N2
+F9
+E1
+F83
+L90
+E5
+F44
+L90
+F92
+W5
+R270
+E4
+S1
+F6
+L90
+F96
+R90
+N1
+E4
+N1
+W3
+S2
+S4
+F39
+E1
+S1
+F82
+S3
+F78
+L90
+N4
+E1
+N2
+R90
+F63
+S3
+L180
+F52
+W2
+F49
+W2
+L270
+N1
+R180
+E3
+F79
+F73
+N1
+R90
+N3
+R180
+S2
+F35
+S1
+F43
+S1
+R90
+S4
+W4
+F12
+S1
+F2
+N3
+E4
+L90
+F51
+R90
+N4
+F90
+R90
+F99
+E3
+N1
+R90
+S3
+L270
+W5
+L90
+R270
+F50
+N5
+F33
+S3
+F18
+L90
+E4
+L180
+W4
+R90
+F21
+W4
+F24
+W2
+E5
+N3
+W1
+R90
+W3
+S3
+F82
+W1
+S1
+F12
+N3
+L90
+F37
+R180
+F36
+F27
+E3
+S3
+F36
+W4
+S1
+F6
+R90
+F59
+S1
+E1
+R180
+S2
+W3
+L90
+F45
+R90
+E1
+F29
+S5
+W3
+S5
+W4
+L270
+S2
+F13
+E4
+F28
+R90
+F80
+S4
+E1
+S2
+F62
+R90
+F26
+L180
+F19
+W2
+L180
+W5
+F15
+N1
+F68
+E4
+F75
+S2
+F58
+S4
+R180
+E3
+N1
+L90
+S2
+F12
+R90
+E5
+S5
+W4
+N5
+W1
+R180
+S1
+F70
+R90
+F97
+L90
+E3
+S3
+L270
+E1
+F51
+N4
+L180
+N1
+R90
+F42
--- a/input/day12_example.txt
+++ b/input/day12_example.txt
@@ -0,0 +1,5 @@
+F10
+N3
+F7
+R90
+F11
--- a/input/day13.txt
+++ b/input/day13.txt
@@ -0,0 +1,2 @@
+1006605
+19,x,x,x,x,x,x,x,x,x,x,x,x,37,x,x,x,x,x,883,x,x,x,x,x,x,x,23,x,x,x,x,13,x,x,x,17,x,x,x,x,x,x,x,x,x,x,x,x,x,797,x,x,x,x,x,x,x,x,x,41,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,x,29
--- a/input/day13_example.txt
+++ b/input/day13_example.txt
@@ -0,0 +1,7 @@
+939
+3,7919
+7,31
+67,7,x,59,61
+1789,37,47,1889
+7,13,x,x,59,x,31,19
+67,x,7,59,61
--- a/input/day14.txt
+++ b/input/day14.txt
@@ -0,0 +1,567 @@
+mask = X111000X0101100001000000100011X0000X
+mem[4812] = 133322396
+mem[39136] = 1924962
+mem[35697] = 29912136
+mem[41065] = 2558851
+mask = 11001101X110000X010X01101100X1X0X001
+mem[38134] = 481
+mem[53084] = 5470
+mem[37619] = 2696
+mem[12248] = 262787806
+mask = 011011000111X1000100010X00XXX0X010X0
+mem[47555] = 417868017
+mem[43020] = 11374336
+mem[9849] = 677
+mem[10472] = 2780071
+mem[6278] = 44095
+mem[61339] = 4820103
+mask = 0001X1X0111101X0000000101110101XX010
+mem[54969] = 910
+mem[39162] = 100172
+mem[17392] = 11619
+mask = 110111X10111010X00000X1X10011X00X001
+mem[45516] = 1541
+mem[4373] = 50557596
+mem[59075] = 12671
+mask = 110111XX0X100100000011011001XX0XX100
+mem[62464] = 171815
+mem[46196] = 148784
+mem[20537] = 616
+mem[21990] = 737337799
+mem[5155] = 1869813
+mem[55244] = 25386
+mask = 1X011XXX0X110X000000111111X0010X1100
+mem[14027] = 131770871
+mem[35273] = 329
+mem[27168] = 13145
+mem[15552] = 20442
+mask = 000011110X1X1110100011XX010X0X0X00XX
+mem[45041] = 535
+mem[41349] = 2943
+mem[32249] = 13150
+mem[42109] = 12648516
+mem[38042] = 469004
+mem[31535] = 3710
+mem[36786] = 4985
+mask = 01XX01X10111X0X1XX0X011111101110X000
+mem[21541] = 149981598
+mem[55577] = 358503898
+mask = 010XXXX10X100000010010010001011XX1XX
+mem[61804] = 6027
+mem[31021] = 7248
+mem[13164] = 3531
+mem[44086] = 3037407
+mem[36788] = 692
+mask = 000X1111011XX0100000X1011101X110XX00
+mem[54870] = 3410195
+mem[56040] = 124015462
+mem[44086] = 7010
+mem[12761] = 1494532
+mem[19537] = 46357
+mask = 1100110X01101100X0001100111X000110X0
+mem[22275] = 64052559
+mem[44465] = 140458063
+mem[40841] = 137069
+mem[3249] = 32613
+mask = 01011X010010011X01011001000000X01X00
+mem[39991] = 823052
+mem[9454] = 18550503
+mem[46196] = 49070
+mask = 00001X110011X1110XX0X011XX0X00100111
+mem[24003] = 69183
+mem[51214] = 1231
+mem[11159] = 190497327
+mem[60674] = 2663233
+mem[45359] = 221181147
+mem[24393] = 6821
+mask = 0X00XXX1011100XX0100X11110X001110001
+mem[2424] = 16287
+mem[62077] = 204882244
+mem[51144] = 1552
+mask = 0X011X11001101X00000000X10010101X000
+mem[52533] = 814
+mem[62367] = 2681
+mem[15329] = 2524
+mem[5958] = 33152916
+mem[5169] = 14940999
+mem[7316] = 16737491
+mem[46594] = 82304549
+mask = X0011111X11X0010X0X000000X0X01000000
+mem[33860] = 9277
+mem[40193] = 5247776
+mem[21536] = 5090
+mem[55159] = 525789978
+mem[7272] = 1947
+mem[43269] = 1262
+mem[60321] = 366
+mask = 0001111100111X10000X0X0001XX0110X001
+mem[39371] = 20355
+mem[20076] = 130194
+mem[62464] = 165608
+mem[5363] = 12798999
+mem[23392] = 172431
+mem[26007] = 1025238334
+mem[31848] = 2690303
+mask = 01000001XX1X0000010010X0001X1111X001
+mem[47846] = 67159609
+mem[20937] = 4060
+mem[25317] = 2498
+mem[3297] = 10289
+mem[24930] = 32257217
+mem[18446] = 224279204
+mask = 1X01111100X1010X00X0001100011001010X
+mem[13122] = 14370686
+mem[4812] = 1894
+mem[6609] = 52772339
+mem[14721] = 1976711
+mask = 01X1X111X011X000X000000X00X10100X000
+mem[40113] = 2623234
+mem[323] = 652
+mem[1945] = 7426
+mem[57708] = 9306
+mask = 11011X101X100100000001110100X111000X
+mem[33159] = 2659
+mem[22884] = 64195
+mem[834] = 833
+mem[45165] = 9968
+mem[28935] = 4681138
+mem[44677] = 505010306
+mask = 1101110X0X11010000001X010X001X000X00
+mem[16970] = 183048247
+mem[42799] = 257494062
+mem[13112] = 533254525
+mem[62010] = 512202
+mem[20033] = 426
+mem[43020] = 400947
+mem[48764] = 118538673
+mask = 0001X1X10011111000X1000X101XX010X0X0
+mem[27241] = 68762
+mem[32235] = 3226
+mem[20033] = 371335116
+mask = 0100110101110000X1X1XX11X011X01X1100
+mem[54774] = 1707102
+mem[53424] = 1648856
+mem[15029] = 167830926
+mask = 11X11101X01000000100010XX00101100100
+mem[56937] = 2076568
+mem[44446] = 3568
+mask = 0X01011XX11XX1X000001X11000100010010
+mem[26707] = 257188
+mem[20837] = 1147
+mem[35774] = 8287058
+mem[59176] = 31911785
+mem[50627] = 323142
+mem[51555] = 112545
+mem[13400] = 2049087
+mask = 010101010111000001X0X010X01101X10100
+mem[2294] = 1466
+mem[31885] = 1602
+mem[59859] = 61908
+mask = X0001001011100X10X0011X1X0X0X11110X1
+mem[27773] = 7111614
+mem[39484] = 7001259
+mem[31946] = 84116977
+mem[39162] = 96247952
+mem[51914] = 12595221
+mem[49298] = 71588604
+mask = X0X0X100101101XX0000001X100000000001
+mem[48415] = 80182
+mem[59003] = 7049
+mem[6017] = 2787426
+mask = 0X0X1X1101100010000X10000110111X0000
+mem[24393] = 4269
+mem[23336] = 64391144
+mem[46643] = 130406
+mem[59662] = 113947
+mask = 01X0XX0X01110X00010X0100001X01X0X001
+mem[25720] = 322160
+mem[57525] = 111148340
+mem[43480] = 1919
+mask = 010XX111001100X0000X0001000101X00X11
+mem[33465] = 911366523
+mem[13169] = 81794
+mem[57515] = 1697
+mem[4419] = 29555
+mem[4240] = 416685
+mem[26177] = 28183
+mask = X001X11X111100100XX010000X0101X00000
+mem[65077] = 6440266
+mem[33028] = 10910
+mask = 100110111110001X100000011X00X110X000
+mem[8931] = 10038533
+mem[53984] = 2831
+mem[17466] = 14082894
+mem[38326] = 49428809
+mem[4156] = 9647963
+mask = 01001001011XX0X101X0111111001XX01X10
+mem[28561] = 7722001
+mem[53427] = 179659
+mem[37705] = 1016
+mem[32033] = 1659677
+mem[42597] = 97610103
+mem[40939] = 126093
+mask = X001111X00X110100000001X010101110000
+mem[39162] = 1420260
+mem[49152] = 2802
+mem[54774] = 2549
+mem[6401] = 1061
+mem[25048] = 791
+mem[21448] = 56382
+mask = 0X011X1X1110X01XX010000101010XXX0000
+mem[12854] = 4443
+mem[16736] = 3097
+mem[15329] = 2868
+mask = X1011X0100100XX001X1X001X10XX1101110
+mem[22173] = 146697
+mem[11532] = 4316
+mem[41112] = 143103
+mem[35929] = 36019
+mem[14185] = 18987
+mask = 010011X1011X00000X0X1110000X0X1X100X
+mem[51323] = 196738
+mem[20861] = 775
+mem[49853] = 5614963
+mem[4852] = 4092504
+mem[34732] = 10160
+mem[63865] = 552463
+mem[53015] = 35092
+mask = 110111X00011X1X00X1000X110010000X000
+mem[59891] = 1040
+mem[14027] = 831
+mem[14721] = 431731202
+mem[43480] = 136732740
+mem[62010] = 53198026
+mem[52533] = 65
+mask = X1011110001X01XX00X000X0X0011X0X0000
+mem[63869] = 7097798
+mem[65485] = 43091
+mem[12625] = 258935
+mask = 1001111111100101000X00111XX100110X11
+mem[29081] = 743
+mem[11697] = 449089661
+mem[27440] = 361017403
+mask = 1X01111111X1001010X00X000X1X11100000
+mem[61025] = 167531331
+mem[42074] = 92704
+mem[18402] = 472
+mem[40360] = 280090
+mem[5198] = 87354676
+mem[9957] = 234433
+mask = 0X001001011XX01101101111111X110010X1
+mem[50537] = 346959
+mem[21274] = 2621975
+mem[4434] = 22182688
+mem[14816] = 111642816
+mem[45030] = 1047
+mask = X10111010X100000010XX001110X0X0X11X0
+mem[54995] = 10747901
+mem[56949] = 580474160
+mem[13122] = 1836825
+mem[53718] = 320640
+mem[46066] = 20031967
+mem[9592] = 496370249
+mask = 011X000101X1X000010XX00XX0X001110X00
+mem[63634] = 58
+mem[6549] = 125465708
+mem[65227] = 106568
+mem[7157] = 119628
+mem[53879] = 3596
+mem[24737] = 2988756
+mem[28613] = 30239165
+mask = 0000X1X10011011100001111110X000011X1
+mem[20783] = 23844666
+mem[60525] = 119787833
+mem[25174] = 31103270
+mask = 1101110X011X000X000011111111110X1101
+mem[45272] = 46518537
+mem[3148] = 1496883
+mem[42109] = 267291213
+mem[45414] = 29326966
+mask = 0X0010010111X011010011X0X11001101101
+mem[55042] = 14456992
+mem[30328] = 1191922
+mem[51217] = 39478
+mem[1322] = 2415193
+mem[24047] = 687485
+mask = X1011001XX1X00000X1110011100X110101X
+mem[42521] = 44802983
+mem[45188] = 10474
+mem[14816] = 1004064
+mask = X00111XX1110010X000001X11XX000010XX1
+mem[64649] = 1321
+mem[27940] = 9780
+mem[10759] = 1316
+mem[42260] = 637
+mask = 000001XXX110X000011X00X0X11111X1011X
+mem[8130] = 586439
+mem[20778] = 6114
+mem[41065] = 69134521
+mem[57668] = 25104
+mask = 0001111000XX010000000001X0X110000001
+mem[10566] = 242598767
+mem[10513] = 341510032
+mem[4240] = 11342
+mem[39251] = 1852
+mem[52533] = 505
+mem[62768] = 1846627
+mem[41273] = 78405
+mask = 110111X000X101000X00X001111X11000001
+mem[33847] = 843
+mem[61025] = 231
+mem[32862] = 3139142
+mem[39477] = 104793
+mem[48709] = 22758
+mem[34944] = 81906
+mem[60884] = 922756598
+mask = 01XX10X1X0X00110011100X1001000X01110
+mem[34411] = 14772
+mem[9081] = 3144
+mem[61341] = 5637589
+mem[50639] = 938779
+mem[50087] = 920425693
+mask = 00001X1100111X1XX0000011X00000000101
+mem[20861] = 406200
+mem[59075] = 9157990
+mem[21990] = 505513
+mem[9592] = 413
+mem[17466] = 858
+mem[8519] = 949888
+mask = 0110X1X00111X1000X0010100010110XX100
+mem[49665] = 865148
+mem[4812] = 68414685
+mem[34425] = 226483883
+mem[63865] = 2137555
+mask = 000111100110010000XXX11110110100X001
+mem[8335] = 716
+mem[46594] = 986
+mem[50399] = 186
+mem[10648] = 865
+mem[22244] = 24152
+mem[34859] = 58911
+mask = 11011X00001X0100001001111X10X0010101
+mem[57303] = 25331540
+mem[51255] = 24
+mem[47101] = 73094
+mem[33918] = 1216
+mem[29564] = 1997625
+mask = 0001111X1X1X0X1000X00XXX0101X0100000
+mem[41256] = 6851204
+mem[64098] = 3891136
+mem[4192] = 1119
+mem[63634] = 412948
+mem[7034] = 184980285
+mask = 0X11X00101111000X10001100100011X1011
+mem[52085] = 320289
+mem[61015] = 172827015
+mem[58495] = 1213483
+mem[31021] = 8612509
+mem[33625] = 36389
+mem[24830] = 609539269
+mask = 1001111X0001010XXX0000X01X0011X10000
+mem[4652] = 50833
+mem[14676] = 853672
+mask = 110011XX0110XX000X001100XX001X010X00
+mem[2230] = 13635
+mem[26596] = 1541
+mem[48691] = 3294711
+mem[54923] = 402638
+mem[16937] = 5998214
+mem[45115] = 914360
+mask = 0X1011000111XX00010011011X00010X0X01
+mem[45320] = 48783
+mem[26007] = 8905339
+mem[17200] = 675445941
+mem[16192] = 2472925
+mem[32043] = 18546
+mask = 0X0X010XX110X0X001X0X010110111000110
+mem[13424] = 2992684
+mem[36655] = 2952618
+mem[15191] = 15889
+mem[46410] = 4107
+mem[10930] = 254266
+mem[17174] = 25
+mask = 01X1010101X000XX010X1X01001101X10000
+mem[46463] = 136939958
+mem[12384] = 35808
+mem[25429] = 58008820
+mem[45359] = 87512582
+mask = 010X1X100011X1X10X0000000001000X0XX1
+mem[46605] = 1230722
+mem[25174] = 437033994
+mem[12673] = 730
+mem[19856] = 1681
+mask = 000X11X0X0110100000000011X11100X0XX1
+mem[11408] = 935967
+mem[20861] = 1048829
+mem[24219] = 67911289
+mask = X1X1110X00X1X0000000111110100XX10000
+mem[40028] = 1018
+mem[59183] = 14694
+mem[2921] = 862972454
+mem[13885] = 4679694
+mem[43628] = 19289
+mask = 000X111X0011X11000010X01X00000101XX1
+mem[12269] = 3866
+mem[17658] = 614591
+mem[9957] = 408492346
+mem[11396] = 4758
+mem[12897] = 14036510
+mask = 01011X100X11010000000X01000111000X01
+mem[19856] = 191255190
+mem[12106] = 3753509
+mem[6353] = 57008
+mem[39019] = 12566363
+mem[48517] = 12346
+mem[8240] = 83254479
+mem[50020] = 11399
+mask = 00011111001X100X0000110000X1X1101X01
+mem[52533] = 2830
+mem[1266] = 7910
+mem[61174] = 2820
+mem[20861] = 95813054
+mem[56965] = 862485
+mem[62822] = 41372
+mem[47420] = 11474585
+mask = 0101111110X001000XXXX0101X1X01000100
+mem[10414] = 48452289
+mem[7061] = 23575482
+mem[8503] = 63531
+mem[42733] = 4606968
+mask = 11XX11100010010X000000110000X000XX01
+mem[25088] = 120084812
+mem[3201] = 6845180
+mem[9592] = 1020
+mem[4433] = 22837
+mask = XX01111XXX1X01000000001110010X010X01
+mem[4240] = 23113
+mem[12224] = 858638082
+mem[17504] = 317
+mask = 0000111100111110X00XX101XX0XX1X110X1
+mem[745] = 904
+mem[53504] = 162
+mem[31021] = 45256
+mask = XXX11100001X01000010X1X1X0X1111110X1
+mem[46463] = 38058788
+mem[31885] = 2525105
+mem[62077] = 13891952
+mem[56140] = 1865
+mem[4652] = 800219
+mem[43269] = 240797
+mem[35058] = 29633574
+mask = 01010101011X000001XX00X01X010001XX1X
+mem[32862] = 187905
+mem[15688] = 239625041
+mem[3826] = 7177029
+mem[45414] = 1397
+mem[3363] = 1396790
+mem[21976] = 10750
+mask = 00X0111100X1X110X00X0100X00XX0111X11
+mem[6233] = 565
+mem[51991] = 1735
+mem[28206] = 1317648
+mem[25174] = 880610
+mask = 110111110X1X0000000010000110010XXX11
+mem[32463] = 8176
+mem[8050] = 6174
+mem[55638] = 3675533
+mem[46594] = 178473
+mask = X00X1X111110001010X000011000001XXX00
+mem[27567] = 1662437
+mem[10759] = 6467
+mem[8908] = 1030
+mem[6248] = 2655
+mask = 0100100001110000010110XX00001XX0010X
+mem[2639] = 8577236
+mem[34870] = 65836
+mem[4053] = 222391
+mem[57945] = 855831793
+mask = 1X011101011X00X0010X0XX1001101111100
+mem[55806] = 1749
+mem[14816] = 56071
+mem[64085] = 451286812
+mem[36655] = 539840
+mask = 0X0X11110X11XXX000000XX1000001000X00
+mem[28935] = 1035091
+mem[28017] = 7410228
+mem[17504] = 6484
+mem[63869] = 56633
+mask = X10X010X0010X00000010011011101001X10
+mem[20976] = 391341
+mem[13770] = 245061
+mask = X10X110X011000000XXX0101111011001001
+mem[55892] = 6223387
+mem[13408] = 26636189
+mem[18959] = 15512439
+mem[13486] = 547061
+mem[51417] = 1732
+mem[47710] = 191002
+mask = 0100111XX110X000X00XX011X0X000101100
+mem[59547] = 6680490
+mem[53421] = 32962554
+mem[4053] = 54327681
+mask = X100X10101100000000XX1X00000X11010X0
+mem[43106] = 972
+mem[16979] = 1712450
+mem[21809] = 60684
+mem[7034] = 32377
+mem[62077] = 1144693
+mask = 110001X1X11000X0X0X0100010000110XX00
+mem[45989] = 43960
+mem[26220] = 2635467
+mem[16394] = 88577466
+mask = 000XX1XX01X0010000000X0010100100XX00
+mem[29081] = 10123
+mem[24649] = 319
+mem[13486] = 1774
+mem[46037] = 182
+mem[17651] = 48948
+mask = 00X111110011110000000X00010X0X000000
+mem[12407] = 3445366
+mem[26177] = 40338
+mem[13408] = 867129107
+mask = 01001X01011000X00X00010100101XX1X010
+mem[36968] = 115095
+mem[5759] = 178851
+mem[27773] = 191592
+mem[35287] = 2056
+mem[26888] = 386883
+mem[20525] = 34626
+mask = 00X1X1100110X100X00001101000010000X0
+mem[27168] = 686235562
+mem[25070] = 380483
+mem[18945] = 1696
+mem[4979] = 15419
+mask = 00XX111100X0010000X0X01X1011X0X1000X
+mem[15024] = 101402
+mem[6571] = 734201087
+mask = 010XX101001000000X01001101XX00001110
+mem[8062] = 974626
+mem[3308] = 45423
+mem[12897] = 147472
+mem[54774] = 247807
+mem[51694] = 1156
+mem[8908] = 615
+mask = 01X011000111110XX1X0011001X101X01001
+mem[1998] = 8383268
+mem[9454] = 105136
+mem[39479] = 6515
+mem[1360] = 239170
+mem[62970] = 13188849
+mask = X001X1110X100100000000111X0100X100XX
+mem[23516] = 899356468
+mem[58739] = 449
+mem[7316] = 4769
+mem[9857] = 373639523
+mem[48106] = 1417
+mask = 1100110101X00000XX011000010111111X01
+mem[8712] = 500891722
+mem[16579] = 431756695
+mem[34425] = 3712
+mem[40112] = 426
+mem[36630] = 610
+mem[20554] = 933886
+mem[48342] = 177911
+mask = 00011X11011X010X00000011X10010X10111
+mem[6531] = 1493325
+mem[35058] = 21547
+mem[13400] = 5230289
--- a/input/day14_example.txt
+++ b/input/day14_example.txt
@@ -0,0 +1,4 @@
+mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X
+mem[8] = 11
+mem[7] = 101
+mem[8] = 0
--- a/input/day15.txt
+++ b/input/day15.txt
@@ -0,0 +1 @@
+17,1,3,16,19,0
--- a/input/day15_example.txt
+++ b/input/day15_example.txt
@@ -0,0 +1 @@
+0,3,6
--- a/input/day16.txt
+++ b/input/day16.txt
@@ -0,0 +1,262 @@
+departure location: 50-692 or 705-969
+departure station: 35-540 or 556-965
+departure platform: 27-776 or 790-974
+departure track: 48-903 or 911-955
+departure date: 33-814 or 836-953
+departure time: 34-403 or 421-966
+arrival location: 37-489 or 510-963
+arrival station: 46-128 or 150-960
+arrival platform: 45-75 or 97-959
+arrival track: 28-535 or 541-952
+class: 38-340 or 349-966
+duration: 42-308 or 316-969
+price: 49-324 or 340-970
+route: 31-627 or 648-952
+row: 38-878 or 893-955
+seat: 39-54 or 71-967
+train: 36-597 or 615-960
+type: 41-438 or 453-959
+wagon: 42-370 or 389-971
+zone: 36-114 or 127-965
+
+your ticket:
+107,157,197,181,71,113,179,109,97,163,73,53,101,193,173,151,167,191,127,103
+
+nearby tickets:
+460,805,566,621,266,233,771,202,368,751,150,558,184,248,457,424,351,184,821,623
+181,792,526,790,876,286,436,893,566,195,168,619,911,190,895,803,679,346,323,914
+198,396,154,361,573,941,264,591,596,365,416,191,512,422,813,871,340,912,750,202
+726,194,756,858,569,924,732,592,726,479,650,189,477,268,834,455,732,692,776,97
+228,58,182,728,763,308,290,912,871,686,475,208,593,250,733,729,463,803,360,307
+216,652,486,597,289,188,291,739,300,111,357,359,161,166,745,102,66,520,688,715
+349,265,286,852,869,474,277,261,716,368,403,397,564,850,663,165,356,602,208,355
+283,615,859,258,264,164,714,458,434,723,483,161,226,653,531,750,860,674,906,805
+292,284,177,622,726,768,784,895,203,896,305,663,807,456,188,661,677,648,531,323
+797,877,472,801,612,213,681,392,666,568,398,557,717,813,112,595,927,169,489,679
+804,485,843,563,514,726,299,537,189,754,256,749,278,203,843,299,482,306,158,738
+360,790,810,399,534,192,182,810,686,512,929,791,291,584,529,418,531,760,866,128
+314,919,923,678,656,859,671,942,568,564,241,619,712,460,153,245,276,685,229,456
+989,943,666,917,291,803,205,579,254,489,524,183,461,894,424,895,865,759,802,938
+370,603,736,619,427,197,618,511,199,267,318,322,916,525,659,656,927,854,393,169
+794,616,185,689,796,258,288,100,705,932,712,801,103,725,238,514,730,590,344,271
+902,924,709,317,874,803,216,305,468,596,941,517,841,288,526,781,205,710,98,654
+513,292,427,860,304,221,277,669,458,581,945,58,264,320,561,292,921,678,459,259
+790,615,203,320,128,477,313,203,431,797,719,588,323,857,851,299,199,715,895,430
+928,480,591,740,274,929,279,844,984,651,937,715,282,238,466,257,170,734,240,54
+650,768,201,875,474,523,58,243,900,306,185,801,790,170,749,842,765,298,852,207
+596,688,432,230,667,648,666,652,949,316,894,718,276,920,322,121,730,844,903,162
+862,205,71,219,454,210,801,996,51,316,322,464,719,725,228,281,461,922,222,723
+753,903,760,706,513,898,420,350,772,165,900,320,939,559,741,320,253,521,224,623
+483,155,792,462,261,221,748,206,813,182,520,774,727,239,343,396,679,912,660,435
+573,252,560,108,458,277,468,467,132,488,217,112,936,362,398,322,946,718,927,668
+185,737,233,721,112,288,296,869,233,584,750,187,588,986,164,216,563,301,423,191
+689,945,353,575,221,774,518,235,557,529,454,455,916,436,799,907,209,54,800,256
+533,562,558,678,567,565,721,729,511,243,228,368,345,527,306,812,689,390,257,684
+66,189,579,515,474,655,591,208,240,733,662,237,257,850,291,473,227,846,558,768
+218,688,651,918,931,461,531,320,173,240,775,114,241,803,909,719,523,684,170,220
+468,370,913,591,280,753,675,477,582,608,937,942,250,900,157,303,805,746,690,485
+182,477,685,669,153,360,366,533,254,288,243,228,395,62,799,853,718,590,937,615
+590,268,807,790,154,576,867,663,294,315,365,946,303,692,768,896,736,939,838,760
+599,592,474,203,190,291,651,431,914,349,715,944,666,197,286,806,488,799,713,101
+471,713,579,232,556,283,915,185,927,167,354,591,560,560,171,353,584,296,10,679
+353,757,179,101,982,805,213,438,303,914,851,799,556,72,469,275,741,249,360,655
+267,459,460,940,708,589,528,575,285,841,623,585,769,436,652,298,251,997,107,114
+911,255,661,935,286,663,150,680,270,812,751,257,162,127,934,364,764,60,573,717
+360,894,516,664,359,276,600,361,107,432,859,585,288,876,863,166,624,107,453,917
+531,266,199,235,597,246,162,740,70,690,894,729,734,936,201,685,712,172,236,872
+71,532,668,483,680,469,266,392,691,625,361,482,195,752,586,257,234,732,693,935
+114,565,299,437,735,710,930,429,350,799,434,567,293,392,590,64,283,531,518,764
+434,216,72,368,263,597,658,944,949,400,763,128,676,428,122,659,841,924,773,303
+399,931,922,874,870,744,804,424,679,67,228,184,206,166,938,163,689,575,356,900
+915,934,767,930,71,338,483,166,194,591,511,192,237,859,227,574,767,323,219,183
+569,192,773,676,255,176,423,194,842,865,160,667,916,681,894,545,398,581,150,258
+369,50,666,211,595,579,661,71,483,672,712,597,519,737,310,168,836,238,689,580
+945,239,152,108,878,773,720,530,663,727,523,694,754,390,528,261,472,767,233,671
+715,570,368,809,534,282,101,234,98,510,647,734,811,897,691,365,705,100,427,487
+278,357,54,598,773,648,179,247,709,738,474,859,852,627,392,650,615,259,913,752
+686,484,113,247,282,428,871,843,196,368,297,487,804,870,779,293,224,527,769,722
+894,369,474,569,217,567,770,906,157,400,195,933,357,562,171,805,727,287,256,204
+101,928,670,944,729,113,757,521,587,582,105,433,744,666,726,877,898,389,101,23
+844,843,842,776,775,851,272,349,187,516,925,683,438,851,356,108,192,725,55,657
+510,532,588,320,863,864,615,703,208,462,210,733,899,422,923,667,656,663,755,841
+710,907,390,268,273,271,875,922,530,664,770,725,742,767,742,170,306,587,483,560
+428,922,521,421,728,658,762,465,583,903,898,668,918,945,857,864,229,311,269,874
+841,164,705,204,648,535,771,800,285,288,658,739,686,574,692,945,197,902,291,604
+347,293,294,290,571,569,669,365,839,597,238,708,755,903,300,716,862,240,731,770
+893,436,206,814,67,150,218,288,841,762,758,214,479,463,535,231,530,453,732,239
+659,943,253,806,268,904,392,173,870,845,836,752,468,941,355,838,400,590,51,868
+187,914,323,943,459,127,717,317,399,169,356,206,216,648,239,243,608,810,689,653
+171,303,689,433,357,874,731,758,370,256,540,207,557,941,627,864,281,216,458,318
+774,760,522,249,877,675,347,231,368,168,319,153,561,186,302,262,400,425,580,481
+150,313,473,616,162,237,869,485,188,619,925,324,182,802,340,256,470,850,356,685
+281,183,862,487,519,195,595,652,975,169,730,776,98,235,619,163,926,576,155,581
+293,222,472,651,150,595,763,519,470,437,262,768,474,358,360,702,836,162,877,154
+585,651,902,224,245,215,300,478,122,193,276,288,940,200,875,74,686,429,458,219
+684,247,527,766,915,574,556,729,203,668,268,474,394,771,231,933,668,475,537,656
+948,167,988,196,802,250,462,364,362,291,488,389,619,941,594,901,623,207,471,709
+588,111,155,662,977,53,806,215,727,246,265,718,596,367,437,271,725,453,322,916
+557,597,850,811,721,242,238,854,682,295,259,300,568,278,903,278,433,577,784,532
+731,624,101,900,802,934,565,429,670,453,757,322,208,73,251,366,344,465,728,871
+172,650,807,459,673,392,752,263,488,845,517,319,515,155,232,809,948,245,761,997
+485,103,159,532,272,895,101,277,917,708,9,220,396,152,587,422,911,753,754,588
+390,767,561,467,583,763,741,506,574,770,487,621,232,287,737,160,236,758,458,655
+106,307,660,430,249,306,542,533,453,912,233,869,800,735,431,280,899,257,162,299
+103,365,731,623,749,775,98,898,763,560,316,431,197,153,222,267,621,493,930,286
+737,761,725,223,945,153,562,717,893,480,869,899,557,902,107,859,685,236,413,480
+272,876,992,217,295,747,843,359,836,485,758,103,692,560,738,323,462,174,620,862
+233,484,621,292,534,461,869,863,457,457,121,733,114,739,72,585,798,916,242,680
+577,586,911,158,351,934,978,558,164,233,795,179,924,852,278,305,740,107,772,557
+748,661,932,668,743,929,218,394,933,170,161,724,336,659,592,204,556,517,289,669
+659,573,988,522,591,763,151,933,359,201,913,427,155,214,196,234,340,402,253,98
+271,262,273,669,156,538,804,859,713,653,873,594,168,847,113,219,667,211,352,152
+899,678,364,766,390,432,863,812,660,622,652,235,585,677,669,366,103,621,146,218
+433,236,625,567,852,351,211,922,395,681,935,52,354,362,652,765,203,905,560,792
+733,731,254,101,217,761,709,708,917,393,627,755,461,240,540,302,297,307,516,865
+247,862,842,688,486,227,928,398,831,168,742,514,733,308,110,127,285,571,424,202
+290,665,469,192,863,101,759,80,435,652,759,223,114,213,858,477,466,481,390,263
+476,192,864,896,458,933,983,840,292,650,263,150,931,867,71,525,215,525,482,875
+294,847,160,231,99,236,463,836,763,798,751,396,570,156,610,913,588,858,930,845
+798,878,197,301,224,110,352,621,766,925,195,654,310,837,434,215,667,209,355,174
+585,287,189,568,425,618,267,924,517,810,687,718,391,466,21,238,396,843,862,517
+170,103,811,511,719,896,622,937,204,658,156,909,774,363,359,474,867,399,224,534
+168,776,285,858,265,65,757,270,530,203,914,151,427,112,593,665,317,756,157,734
+622,513,424,287,99,220,855,947,623,792,153,425,558,765,358,338,453,763,213,433
+156,398,799,675,857,480,755,622,234,425,872,730,767,293,993,72,278,168,340,671
+246,618,206,102,794,792,873,396,457,737,916,214,946,987,365,422,398,256,877,152
+587,690,263,151,582,624,513,560,854,263,890,218,212,841,520,233,754,588,531,151
+626,943,916,749,771,619,709,751,432,364,894,591,66,876,895,262,937,151,431,349
+949,690,871,875,519,243,619,733,458,235,344,264,476,898,754,240,869,733,761,166
+810,592,654,706,174,943,167,560,810,575,392,316,716,309,173,434,854,155,842,459
+521,436,166,808,431,774,567,947,795,225,230,201,991,866,232,764,840,740,790,295
+269,919,587,484,855,794,286,269,733,181,284,322,844,920,903,263,751,391,506,298
+804,896,460,469,163,207,658,916,572,218,172,268,876,708,738,300,394,696,737,864
+280,353,457,103,574,397,903,614,580,840,858,291,650,871,210,464,913,340,71,391
+162,919,488,657,768,812,492,926,397,203,107,520,297,251,181,794,814,170,856,246
+480,462,528,391,393,565,818,793,715,283,324,577,205,811,233,158,510,768,922,732
+934,162,182,401,251,920,758,878,333,72,648,570,874,839,755,673,511,306,154,281
+933,285,663,229,837,776,672,582,472,684,97,460,114,612,839,655,182,162,428,322
+459,243,153,250,726,104,294,621,158,796,164,160,248,621,222,164,875,335,269,913
+226,100,100,288,839,653,238,194,703,478,674,292,284,566,219,278,365,624,179,801
+711,867,234,849,670,359,458,326,108,877,370,760,430,582,672,593,185,212,114,239
+912,737,814,357,214,262,368,451,353,673,460,919,656,596,267,251,662,760,487,725
+840,808,152,513,671,769,166,792,462,480,849,335,364,350,269,854,520,316,946,455
+363,897,745,154,216,457,390,161,214,995,726,204,896,741,237,287,421,392,474,897
+582,582,863,727,802,240,185,567,867,844,724,186,499,938,477,586,710,652,749,264
+161,293,844,172,734,233,241,195,808,583,300,776,164,163,193,579,985,400,296,207
+396,216,896,424,663,870,672,107,942,532,509,559,808,246,895,356,859,913,361,558
+349,100,705,849,618,467,657,401,356,326,767,110,776,652,854,186,734,942,912,532
+306,651,477,800,114,523,478,917,451,743,279,652,731,355,257,288,772,915,727,275
+747,250,390,668,568,949,266,162,721,355,478,464,271,425,305,153,315,935,340,390
+305,622,192,395,390,808,455,890,728,431,242,237,177,850,424,728,351,586,319,846
+571,235,594,473,216,735,474,529,942,453,846,900,620,795,563,273,758,831,127,323
+172,733,585,707,282,674,105,468,357,108,533,245,179,984,393,649,585,191,206,759
+791,453,924,728,945,697,354,324,863,181,206,205,893,709,876,430,804,521,582,928
+930,293,253,174,843,453,283,765,173,247,369,935,364,337,854,470,593,518,761,861
+617,580,656,485,945,895,176,731,280,173,746,774,687,561,162,941,624,926,10,913
+359,156,176,272,395,520,513,51,209,272,809,914,707,184,674,470,537,165,848,719
+898,672,393,246,872,515,226,571,223,217,238,914,680,290,316,496,565,573,355,259
+281,189,577,901,683,523,812,216,913,173,329,75,322,864,795,396,685,673,924,184
+251,740,425,349,422,204,681,680,236,466,808,536,218,804,50,561,718,665,263,895
+878,623,801,167,653,157,526,776,584,289,441,654,654,798,298,270,465,357,354,287
+670,911,690,912,652,519,289,720,311,463,265,219,286,251,232,565,721,736,180,272
+894,793,467,871,204,756,73,948,243,804,725,752,772,172,395,100,678,668,435,977
+675,687,239,175,720,930,199,656,366,731,695,912,794,182,53,217,852,177,155,713
+648,518,715,324,556,784,935,851,468,894,479,759,389,322,299,488,296,272,845,868
+575,475,162,918,172,681,857,617,672,558,100,295,615,878,755,720,177,154,4,217
+945,262,745,588,588,762,112,484,946,872,857,508,851,403,277,265,159,299,681,526
+937,73,710,454,659,174,211,487,358,770,841,562,677,759,485,23,523,523,165,849
+732,922,745,525,688,589,655,316,606,839,590,804,756,53,202,295,866,617,483,764
+717,920,682,766,739,362,188,342,208,476,873,421,237,470,940,847,526,686,913,280
+183,863,18,485,682,304,100,50,581,297,523,340,625,843,672,625,559,351,467,813
+167,362,747,559,192,316,517,756,859,797,396,272,732,17,661,594,742,590,218,901
+894,285,516,774,251,796,949,625,273,873,152,488,582,300,477,425,700,797,151,676
+358,257,566,895,523,729,593,662,767,265,900,922,317,154,899,176,560,349,549,916
+240,252,104,844,758,942,909,844,580,561,877,740,227,914,435,922,711,364,172,182
+947,281,682,716,664,247,73,158,191,769,433,586,771,626,878,932,796,415,655,273
+987,483,511,394,195,101,277,557,470,711,661,318,565,421,866,744,686,903,175,278
+562,681,278,618,587,730,540,859,227,275,316,431,245,254,278,863,427,929,437,592
+158,198,652,196,935,74,837,310,425,250,682,221,721,180,284,510,217,675,197,466
+364,455,680,748,626,317,249,322,456,435,311,435,217,894,318,396,725,665,874,423
+235,588,666,267,390,584,366,848,263,364,573,592,937,758,494,727,275,858,425,461
+776,350,809,433,152,462,896,281,202,303,782,649,688,177,296,104,52,525,101,808
+479,422,933,72,111,928,389,366,653,347,477,681,523,210,485,756,921,690,583,427
+712,901,241,461,773,596,486,657,811,367,573,310,268,798,668,582,389,52,279,525
+353,662,567,316,841,651,400,247,905,517,471,356,932,183,99,482,239,464,556,209
+748,345,587,54,684,247,739,587,767,796,594,776,210,230,913,705,911,211,654,901
+773,158,521,322,277,948,800,763,896,529,361,865,869,573,239,558,826,267,593,106
+949,167,525,0,580,424,102,530,935,362,251,223,227,717,128,241,750,226,899,757
+796,436,529,279,435,312,767,671,229,714,719,529,426,901,803,207,357,793,322,184
+854,724,455,232,155,157,335,672,297,306,262,742,793,251,71,203,201,689,660,749
+921,659,584,571,217,191,226,99,567,403,720,662,902,858,361,312,475,216,583,282
+720,744,479,667,705,361,527,295,10,172,73,934,291,255,705,362,934,559,581,206
+750,933,179,67,400,200,425,948,776,240,201,180,71,189,751,680,430,726,569,709
+361,851,74,214,933,866,712,686,750,227,191,914,536,322,101,462,678,263,766,389
+714,201,227,843,682,103,173,799,578,281,478,151,614,656,197,594,627,721,556,873
+806,798,929,243,289,230,656,648,359,302,394,340,903,744,158,675,247,540,556,581
+715,813,759,794,244,344,191,844,354,481,573,615,726,234,171,616,710,110,656,285
+756,845,483,16,530,557,197,790,202,250,894,691,296,587,795,289,747,220,859,921
+51,739,184,298,155,257,73,897,850,871,667,323,865,319,773,715,328,460,235,214
+203,760,870,345,153,319,803,469,686,705,714,856,220,433,619,428,755,729,475,281
+763,468,361,675,478,222,258,750,482,290,217,767,900,345,583,801,866,185,254,161
+515,944,662,297,486,178,401,17,105,584,843,427,569,284,71,427,617,207,746,369
+194,510,227,233,651,469,229,914,112,840,578,53,748,401,428,426,747,369,314,935
+596,51,878,194,836,211,945,763,278,708,744,948,800,424,63,427,669,740,849,865
+241,50,717,658,735,718,424,899,553,656,911,436,715,170,112,579,461,761,305,294
+353,401,842,865,842,738,945,129,709,759,532,244,518,895,519,723,866,870,616,588
+511,798,294,238,713,204,290,619,186,580,652,389,357,496,594,355,523,931,792,684
+324,672,253,271,273,687,859,712,802,160,605,718,164,573,665,239,255,318,254,521
+230,288,280,666,279,190,929,421,558,706,833,725,190,435,389,843,353,128,810,358
+154,681,359,425,762,400,571,927,536,591,753,471,320,487,718,483,349,770,657,185
+204,103,761,708,240,263,101,565,853,933,518,346,429,717,438,558,840,474,654,300
+654,463,911,792,187,182,518,175,933,207,517,849,473,934,394,539,473,203,518,855
+105,655,913,183,621,945,798,616,420,870,400,911,481,422,170,254,214,73,364,158
+753,867,292,160,687,174,589,560,661,711,519,175,899,308,459,823,873,867,671,653
+128,716,946,278,580,235,657,363,98,428,521,474,649,105,927,858,154,937,604,218
+589,150,940,71,263,741,352,648,800,680,566,530,465,457,420,287,712,173,170,223
+274,735,596,900,662,321,486,241,767,154,725,617,99,918,264,201,557,782,751,429
+943,334,457,518,475,438,159,948,741,308,247,236,591,186,938,273,723,187,307,583
+807,931,720,195,238,304,167,406,170,734,593,349,212,797,893,937,392,842,399,252
+586,281,152,294,876,266,911,189,183,927,141,160,283,181,927,753,478,488,470,427
+916,112,103,282,356,159,901,723,153,808,762,936,194,942,153,110,686,3,250,678
+395,762,281,996,765,239,239,516,278,864,623,178,483,709,529,240,804,560,482,231
+666,857,581,290,913,770,366,584,877,648,474,937,193,865,721,875,907,283,863,560
+595,928,926,207,840,423,573,801,280,292,905,427,716,741,776,574,716,430,192,293
+269,536,562,765,689,170,72,402,198,760,864,307,765,99,255,867,868,713,948,479
+97,837,243,649,192,708,856,58,711,190,426,716,582,649,877,269,187,616,679,903
+893,215,71,485,667,900,911,930,163,660,308,352,214,933,916,203,494,340,946,483
+154,435,728,843,856,928,483,167,936,735,244,861,175,560,917,464,167,160,891,458
+807,722,567,719,874,690,154,657,874,755,586,838,482,431,857,760,870,680,473,982
+859,469,806,422,562,795,176,568,353,291,896,776,863,866,154,587,928,902,655,10
+772,813,253,806,237,610,774,947,104,360,460,425,100,806,597,174,726,50,531,687
+762,176,530,864,306,212,915,153,249,746,552,917,303,261,525,842,752,569,686,876
+513,105,531,799,856,725,252,948,285,217,722,741,165,727,333,176,866,114,922,925
+304,194,583,275,872,930,72,424,75,470,847,876,922,300,148,234,570,527,525,691
+296,74,390,437,877,823,902,758,683,578,688,872,868,768,728,937,867,863,298,255
+743,867,292,595,932,587,915,763,808,249,242,594,717,466,874,896,724,535,167,980
+153,722,184,903,227,460,770,755,732,209,60,756,684,422,187,467,616,840,322,858
+618,928,105,454,355,622,424,306,522,936,866,320,357,943,702,302,156,318,369,455
+649,501,403,532,844,585,255,112,799,162,430,846,650,689,810,947,871,707,737,353
+561,568,620,571,290,725,857,781,895,456,459,844,453,52,690,303,394,262,360,246
+156,761,751,730,257,109,293,947,153,758,316,203,855,259,170,581,574,925,439,234
+249,574,368,111,708,936,895,524,720,765,806,658,586,841,998,687,275,896,217,929
+814,768,617,484,275,751,321,649,784,848,155,272,776,692,206,200,319,296,921,219
+940,576,350,841,661,754,662,930,980,593,706,323,395,930,153,246,920,360,276,916
+808,306,736,191,565,152,626,820,357,716,471,871,569,563,940,480,791,914,356,911
+393,875,758,173,662,455,804,934,508,893,523,252,159,435,290,747,462,307,859,469
+112,430,356,866,264,502,218,256,533,770,431,654,108,763,562,288,746,159,751,238
+758,649,526,102,157,298,248,160,286,682,304,424,301,255,474,615,367,999,516,71
+233,403,724,741,235,166,512,639,212,895,627,350,398,814,922,665,619,918,112,727
+853,224,999,431,796,839,479,280,894,193,520,922,397,318,127,927,291,903,580,854
+177,653,401,575,623,369,677,238,742,228,483,252,239,453,390,16,438,674,596,838
+685,318,872,152,809,653,686,126,477,533,718,925,105,624,473,925,764,213,511,368
+803,107,809,903,706,218,697,321,236,857,657,848,294,750,186,74,208,765,237,369
+594,323,735,764,688,210,279,353,840,842,263,915,235,940,511,342,73,920,278,899
+210,570,753,679,807,524,761,181,732,295,585,200,191,657,554,927,487,765,752,473
+463,229,183,721,432,114,72,106,343,791,838,354,927,740,688,746,535,560,150,870
+793,732,811,572,679,228,574,168,919,280,589,6,296,477,352,283,523,284,203,370
+867,466,757,735,473,763,579,543,737,560,516,392,398,299,318,194,234,915,558,223
+512,705,690,365,939,393,581,192,914,357,865,106,858,725,840,105,863,467,118,681
+250,464,362,993,712,712,626,897,914,256,218,169,848,425,228,841,739,295,671,233
+753,268,756,286,224,678,181,183,254,360,423,604,534,216,235,222,423,914,471,365
+620,238,587,295,771,836,251,159,685,795,206,533,299,230,773,598,352,682,898,937
+244,274,430,751,814,675,676,276,97,913,294,454,72,513,533,773,301,360,336,308
--- a/input/day16_example.txt
+++ b/input/day16_example.txt
@@ -0,0 +1,12 @@
+class: 1-3 or 5-7
+row: 6-11 or 33-44
+seat: 13-40 or 45-50
+
+your ticket:
+7,1,14
+
+nearby tickets:
+7,3,47
+40,4,50
+55,2,20
+38,6,12
--- a/input/day16_example2.txt
+++ b/input/day16_example2.txt
@@ -0,0 +1,11 @@
+class: 0-1 or 4-19
+row: 0-5 or 8-19
+seat: 0-13 or 16-19
+
+your ticket:
+11,12,13
+
+nearby tickets:
+3,9,18
+15,1,5
+5,14,9
--- a/input/day17.txt
+++ b/input/day17.txt
@@ -0,0 +1,8 @@
+..##.#.#
+.#####..
+#.....##
+##.##.#.
+..#...#.
+.#..##..
+.#...#.#
+#..##.##
--- a/input/day17_example.txt
+++ b/input/day17_example.txt
@@ -0,0 +1,3 @@
+.#.
+..#
+###
--- a/input/day18.txt
+++ b/input/day18.txt
@@ -0,0 +1,373 @@
+(4 + (2 * 7) * 4) + (6 * 9 + 8 * 4 + 7 * 3) * 3 * 5
+5 * 9 + (5 * 9) * (6 + 2) + 3 + 7
+8 + 5 * 9 * 9 + 9 + 5
+(7 + 9 * 8 + 4 * 6) + 6 * ((9 + 9 + 5 * 7 + 4) * 8 * 2 + 5 * 6 + 2) + 2 * 6
+(6 * (5 + 8 * 7 * 8 + 4) * (7 + 7 * 3 * 5)) + 5 * (8 + (8 + 3 + 5 + 5) + (3 + 2 + 7 * 2 * 9) + 6 * 5 + (2 * 6)) * ((4 * 3) + 3) + 9 * (3 + 6 * 2 + 3 * 8)
+2 * 9 + (6 * 2 + 6 + (9 + 6 + 8 + 5 + 5) + (8 + 7 * 4 + 3) + 8) * (4 + 4 * 2 + 6)
+5 + 4 + 5 + (7 + (9 + 7 + 4 + 4 + 4 + 5) + 2 * 4) + 4 * 9
+9 + (7 * 8 + (6 + 3 + 4)) + (5 * 9)
+2 * 4 + 8 + (5 + 8) * 9 * (9 + (5 + 3) + 3)
+8 * 6 * 5 + 8 + (8 * (2 + 8 * 7 * 5 + 3 + 5)) * 2
+6 * ((3 + 4 * 3 * 7 * 8) * 8 + (9 + 5 + 2 * 3) * 3 * 2) + 7 + 8 * 8 + 4
+9 + 3 + 7 * 8
+(9 + (4 + 9 + 3 + 5 * 5 + 5) * 5 + 9 * 6) * 3 * 2 * 6 * 5
+7 * 9 * 6
+(5 + 2 * 8) * 8 + 3 + 8
+9 * 5 * (5 + (5 * 4 + 8 + 6 * 5) * (9 * 7 + 5)) * 3 * 9
+(6 * (8 * 3 * 7 + 2) * (3 + 9 + 5 + 5) + 3) + 7 * 3
+7 + 9 + (4 + 9 * (4 * 6 + 3 * 8 * 5) + 8 + 9 + 3) + 6 * (6 + 8 + 7 * 9 * 6 + 6) + 7
+2 * (5 * 5 + 6 + (5 + 5 * 5 + 6)) * 4 + 5 + 2
+8 + 2 * (8 * 7 * 4 + 8) * 9
+9 + 5 * (4 * 8 + 9 * 6 + (3 * 3) + 2) + 5 + (4 * 5 + 2 * 2)
+(5 * 7 + 2) + 3 + 9
+7 * 9 + 8
+3 * 7 * (7 + 5 + 8 * 5 * 8)
+(7 + (3 * 6 + 6 * 9 + 2) * 8 * 6 + 6 + 2) * 6
+4 * (7 * 5 * (6 + 8) * 7 * (5 * 3 * 2 * 9 + 2 * 4) * 6) * 2 + 2 * 5
+((3 * 3 * 9 + 8) + 2 + 5 + 8) + 6 * (6 + 9 * 2) + 7 * 9 * ((9 + 4 + 4) * 4 + 4 + 9)
+7 * (4 * 2 + 3 + 7 + 5) * (8 + 2 + (5 * 9) * 2 + 3 * 5)
+7 + (8 + 3 + 8 * 4 * 2 * 2) + 7 * 2 + ((3 + 5 * 3 + 5) * 8 + 3) + 8
+7 + 2 + 9 * 9 + 5
+((6 + 4 + 2) * 2 + 9) + 3 * 6 * (6 + 4 + 9 + 2 + 6) * 9
+6 + 6 * (9 * 9 + 6 + 6) + 2 * 6
+2 + 5 * ((4 * 4) * 6) + (3 * 3 + 2) * 9 + 5
+9 * 4 + 8 * 5 * ((6 * 5 * 4) + (3 + 8 * 7 + 6 * 7) * (6 * 6 + 7) * 8 + 4 + 7)
+3 * 8 + (4 + (7 * 7 + 9 * 8 * 6 + 7) * (8 * 4 + 4 * 6 * 4 + 4) + 2 * 9)
+3 + 6 * 2 * 3 * (4 + 7 + (3 * 6 + 7 * 8) * 7 + 9 * 8)
+2 + 8 + (5 * 4 * 2 * 5 + 5) * 4 + 3 * 4
+6 + 4 + (5 + 5)
+6 * 3 + 8 + (8 + 2 + 9 * 3) * ((6 * 8 + 6) + 6 + (7 * 4 * 3) * 4 + 9 + 3)
+((9 + 7 + 9 + 2 * 7 * 7) + 8 * 6) + 2 + 7
+6 * (6 + 9 * 2 + 4 * 7 + 8) + 5 * 9
+((2 + 5 + 6 * 3) + 7 + (7 * 6 * 8 * 3 + 8 * 3)) + (8 * 6 * 8 * 9 * 5)
+6 * 7 * 5 + 5 * (2 * 9) * 4
+(8 * 7) * (2 * (7 + 3) + 3) + 8
+(7 * 9 + 7 + 7 + 7 + 7) + (7 * 5 * 8 + 4 * 5) + 6
+5 * (6 * 7 * 8 * 5) * 6
+5 * (2 + (6 * 7) * 8 * 3 + 6 * 2) + 2 * 4 + 8 + 3
+3 * 5 + 6 + 6
+((9 * 9) * 6) + (4 + 9 * 6 + 4 * 9 + 7)
+(3 + 9 + 2) * (3 * 7 * 7 * 7 * (8 * 8 * 4 + 3 + 8)) + 2
+6 * 6 + 8
+((9 + 5 + 8) + 9) + 7 + ((9 * 5) * 3 * (3 * 4 * 4 + 3) * 7) + ((5 + 6 + 2) * (7 * 2 * 9 * 8) * 5)
+6 + (8 * 7 * 6 + 5) + 9 * 7 * 7 * 7
+2 + (4 * 9 * 3 * 9 + 8) + 2 * 7 * 3 + 4
+7 + 3 + (5 + 7 * (4 + 4 * 8) + 2 + 8 * 6) * 2
+(2 * 5 * (4 * 7) * 9 * (3 + 7)) + 3 * 4 * (2 * 3 * 8 * 4) * ((6 + 2 * 2) + (6 * 5 * 7 * 6) + 9 * (8 + 4))
+((9 + 3 + 5) + 8) * 2
+2 + 4 + 7 + 5 * (6 * 7 + 8 * (4 * 3 + 6 * 4 + 7) * (7 + 3 + 7 + 3 * 2) + 8)
+5 + (9 * 8 + 5)
+(2 + (9 + 7 * 8) + (6 + 7) + 6) * 5 + 3 * 2
+7 + (9 + (8 * 7 * 9)) * 8 + 3
+9 * (9 + 4 * 2 * 3 + (6 + 7 * 8 + 9)) + 6 * ((7 * 4 + 7 * 4) + 2 * 6 * 5 + 6 * 6)
+((3 * 3 + 4 * 9) + 7 + 7 + 3) * 8
+9 + 8 * (2 + 6 + 8 * 6 + 3 + (8 * 6 * 6 * 4 * 6))
+3 * (9 + 2 * (9 + 2 * 8) + 3 + 8 * 5) + (9 + 8 + (6 * 9 + 2 + 8 * 5 + 7) * 7) * 2
+((2 + 9) + 3) * 6 * 2 * 2 * 4 + 7
+2 * 3 + 4 + (7 + (7 * 5 * 5 + 5) * 9 + (3 + 3 * 5) + 3 * 8)
+4 * (8 + 2 + (3 * 7 + 4 + 2 * 6 + 2) * 8 + 7)
+4 + (5 * 9 * (8 + 3 * 9 + 9 + 5) * (3 * 8 + 9 * 8)) * 8 + 9
+4 * 5 * (2 + 2 + 7 + (3 * 7 * 4 * 2) + 3) * 6
+((8 * 8 * 4 + 4 + 5) + 6) + 9 * (3 * 3) * 4
+9 * (8 + (6 + 2 * 7 + 3 + 8 * 8) * 3 * (9 + 3) * (3 + 7 * 3) + 5)
+9 * 3
+6 * (7 + 8 * 8 * 4) * 6 * 9 + (4 * 7) * 4
+4 * (3 * (4 * 9 * 6) + 5 + 5) * 4 * 6 * 6 * ((9 + 3 * 6 + 5 + 8) + 4)
+5 * 2 * (4 * 3 + (8 * 4 + 2 + 2) * 6 * (8 * 8 * 2 + 7 + 9) + 3) * 5 + (4 + 6)
+3 + (5 + 6 * 5 * 9) * 9 + 7
+((3 + 6 + 8) * 7 * 3 + 4 + 4 * 8) * 2 * 2
+2 + ((9 + 9 * 4 + 2 + 3) * 4 + 9 + 5 + (7 + 3 * 9)) + 8 + 7 * 3
+5 * 5 * (5 * 6 * 6 + (3 + 4 * 8 + 7) * 2) * 6 + 4 + 3
+4 + 3 * (5 + (6 * 5 + 6 * 2) * 4) + 9 + 7 * (5 * 5 + 9 * 5)
+2 + (6 * 7) + 7 + 3 * 7
+5 * 7 * (6 + (9 * 5)) * 4 + 2
+((7 * 7 * 3) + 2 + 2 + (9 + 8 + 3)) * (3 * 8 + 6) + ((6 + 2 * 6) * (2 * 4 + 3 + 8 + 2)) * 8
+((8 + 3 + 8 + 5 + 8 * 3) * 2 + 4 * (6 + 4)) * 8 * 2 * 5 + 9
+7 + 6 * 3 + 3 + (5 * 7 + 3 + 3 + 8) * 6
+8 + 7 + ((5 * 9 * 3 + 3 + 4 + 6) + (6 * 6 + 2 + 6) + 8)
+5 + 5
+6 + (6 * 5 * 7 + 8)
+(8 + (9 + 2 + 8 + 2 + 2) * 4 + 7 * 6) * 9 * 6 * (6 * 6 * 5 + 5 * 4) + 7 + 9
+3 + 8 + (3 + (6 * 9 + 9 * 2 * 3 * 4) * 3 + 9 * (4 * 2) + (3 * 2 * 9 + 2))
+(5 * 8 + 7 * 8 + (2 + 3 * 8) * (8 + 4 * 7)) * 3
+8 + 2 * (2 + (6 * 6 + 9 * 3 + 6) + (9 * 2 * 4) + 6 * 4 * (6 * 3 + 2 + 6 + 3 + 5)) + 8 + 4 * 9
+8 + 8 + (4 * 9 + 9)
+5 + 5 * (5 + 8 + (3 * 9 * 9 + 8 + 8 * 2) * 5) * (8 + 7 + 7 + 8 + (2 + 7 * 4 * 8))
+6 * 3 + 6 + ((9 * 5 * 4 + 6 + 5 + 5) * 6) * 2 + (6 * 5 + 5 * 7 * 8 * (3 + 7 * 7 * 9))
+4 + (3 + 4 + 5 * (4 * 2 + 7 * 9 + 6 + 6)) + (7 + 7)
+2 * (6 + 2 + 6 * 3 + 4) + (6 + 5 * 4 * 8 + 3 + 7) + 8 + 3 * 5
+((5 + 3 + 7 * 2 + 9 * 5) + 7 * 7 * (4 + 7 + 9) + 8 + 6) + 3
+((9 * 9 + 2 * 7 * 5 * 6) + 8 * 7 * 4 * 2 + 6) * 5 * 9
+((3 * 3 * 2 + 5 + 6) * 7 + (3 * 6 * 2) * 3 + 3) + 9 * 7 + 5
+(7 + (4 + 7 + 6 * 8 + 9 * 9) + 7 * 2 * 2) * 7
+(9 * 3 * 9) + ((2 * 6 * 6 + 9 * 7) * 3) + 3 + 8 + 8
+2 + (3 * 5) * (2 + 8 + 8 * 3 * 6 + 6) * 6 * 9
+(4 * 7 * 7 + 3 + 4) * 3 * 9 + 6 * (2 + 5 * 4)
+(8 * 4 + 3 * 8) * 4 * 5
+(7 + 5 + (4 + 2) + 4) + (2 * 5 * 9 * 2 * 6)
+9 * 4 + 3 + 8 * (2 * 4 + 7 * 2 * 2) * (2 + 6 + 5 + 9 + 5)
+8 + 3 * (6 * 8) + (2 * 4 + 7 * 8)
+(9 + 6 + 3) * 5 + (9 * 8) * 5 + 6 * 5
+((6 * 2 + 6 * 2) + 3 + 7 + 5 * 8) * 2 + 2
+2 + (9 * 3 * 9) * (4 + (6 + 4 + 7) + 5) + 9
+(3 + 4) + 5 + 7 + 7
+9 + 8 + 8 + 7 + 5 + ((2 + 7 * 9 * 7 * 6 * 9) * 8 * 8 + 7 * 3 + 9)
+(8 * 7 * (8 * 7)) * 9 + (4 * (4 + 9) * (7 * 9 + 9 + 6 * 5 + 5) + 7)
+(6 + 7 * 9 + 5 + 5) * 5 * (2 + 6 + (3 * 6) + (7 + 3 + 5 * 5) + 9)
+2 + ((7 + 8 * 2 + 8) * 4 + 2) * 9 * 9 + 8
+8 * 8 * 7 * 2 + 2
+7 * 2 + 9 + ((5 * 2 + 6 * 9 + 8 + 7) + 6 * 2 + 8 + 4 * (3 * 2 * 3 * 2))
+5 * (7 * 5 + (7 * 9) * 4 * 6 * (8 + 7 + 3 + 9 + 9)) * 4
+8 * ((3 + 7 + 5) + 7) + 5 + (6 + 4 + 6 + 4 * 4) + ((2 * 6) * 3) + 9
+3 * 3
+4 * (5 + 5 + 6 + 2 + 7) + 7 * 6
+(7 + 4 + 5 * 9 + 5 + 8) * 8 * (7 * 9 * 9) + 4
+3 + (9 * (7 * 7 + 3 * 4 + 8 + 5) * 7 * (2 * 4) + 9 + 5) * (4 + 7)
+6 * (5 * (6 * 2) + 6 + (4 * 8 + 9) + 3 * (2 * 4 + 4)) * 6 * 5 + 6 + 3
+(9 * 3 * 9) * 8 * 5 * (8 + 3 + 2 + 9)
+(8 + 8 * (8 * 9) + 2 + 7) + 8 * (5 * 7 + 6 + 2 * 4 * 2) + 6 * (3 * 8 + 6) * 2
+2 * (8 * 5 + 7) * 8 + 7 * 9
+4 * 4 * (5 + (5 * 4 + 2 * 9 + 5 + 7)) * 8 * ((4 * 9 + 4) + 6 * (7 + 2 + 4 * 8 * 9))
+4 * 6 + (4 * 8 * 3 * (9 + 8) * 7 * 9)
+(6 + 9 + 3 * 2 + 8 * 8) * 6
+(8 + (3 + 3 + 2 * 3) + (6 + 7 * 6) + 7 * 4 + (9 * 5 * 4 * 6 + 2)) * 2 + 5
+4 * 6 + 2 * 5 * 2 + (5 + 3 + 2 + (5 * 3 * 3 + 7 * 6 + 2) + 8)
+9 + 2 + (7 * 7 + 7 + 9)
+5 + 8 + (8 + (5 + 9 + 6 * 2 * 4 * 4)) * 9
+(2 + 4 + 8 + 7 * 8 * 5) + 3 + 3 + (9 + 9 + (9 * 2 + 6 + 4 + 4) + 6 * 2) + 2
+7 + (6 + 5 * 2 * 9 + 7 + (9 + 7)) * (3 + 6 + 2 * 5 * 3)
+8 + (9 + (4 * 3 * 7 * 7) * 7) + 9 * 6
+6 * 9 * ((8 + 5) + 9) * 7 * 8
+(2 * 9 + 2) + (6 * 3 * 3 + 6 * 7 + 9)
+7 * 5 * (4 * 4 + 7 * 4 + 8 + 3)
+3 * (6 + (5 + 3) + 5) * 3
+(7 * (9 * 5 * 9 + 2 + 4) + 3 * 8 + (9 + 7) + (2 * 9 + 5)) * (6 + 3 * 9 + 3 + (7 + 4 * 9 + 5) + 9) * (8 * 2 + (2 * 9 + 7 + 5 * 4) * 4)
+4 + 7 + 5 + 6 * 8
+5 + 4 + 3
+9 * (6 * 2 + 7 + 5) * 3 * 2 * 2
+7 * 4 + ((6 * 7 * 6 * 8 + 6 * 9) * 7 * 3) + 8
+9 * 5 + 4 + 8 + 8 * 8
+(3 + 6) * 2 * 7 * (2 * 7 + 2 + 6 + 3)
+5 * 2 + 8 * 7 + (4 + 8 + (3 * 6 + 7 * 2 + 4 + 7))
+6 + (8 + 6 * (9 * 7 + 2 + 2 + 3 + 4) * (4 * 7 + 2 + 4 * 3) * 3)
+(8 + 5 * 2) * (9 * 4) + 5
+3 * (4 * 5 * (4 + 3 + 4) + 5 * (3 + 6 + 3 * 7 * 7)) * 3
+2 + 7 + (8 + 3) + 8
+8 * (9 * 8 * 3) + 4
+(2 * 6) * 3
+((9 * 6 + 3 + 3 * 9 + 7) + 2 * (2 + 9 * 8 + 2 * 4) + 9 * 8 + 6) + (5 * 9 * (2 + 7) + 7 * 9) + 7
+4 + 7 * ((3 * 7 + 2) * 9 * 7 * 2 + 4 + 3) * 4 * (3 + 8 * 9) + 6
+9 * (9 + (9 * 6 + 2 * 7 + 6) + 7 * 2 + 2)
+(9 * 2 + 4 + 8 + 6 * 8) * (4 + 8 + 7) * 5 + (4 * 2 + 2) * ((4 * 5) * 8) * 2
+(5 * 9 + 9 + 2) * 3 + ((7 * 5 + 9 * 3) + 2 + 3 + 6 + 7) + 4 * 6 * 6
+9 * 8 + 3 * 4 * (9 + 5 + 7 + 5) * (6 * (7 + 4 * 6 * 7) + 6 * (6 * 5 * 3 + 9 + 4) + (2 * 3 + 3 + 6))
+7 * 6 * 2 + (8 * 9 + (6 * 7 * 8 + 6 + 9 * 8) * 3 + 6)
+5 + 7 * 8 + 2 + ((2 + 4) * 7)
+2 * 5 + 6 * 6 * (3 * 6)
+6 * 6 * 6 * (6 * (4 * 4 + 5) * 4 + 3 + 9) + 4
+((3 * 4 * 7) * 5 * 9 + 7 * 6 + 5) + 2 * 2 * 6 + 4 * 8
+7 * 2 * (3 + (6 * 9 * 9) * 4) * (5 * 8 * 7 * 6 + 2 * 9) * 7
+9 + (6 + 6 + (8 + 8 * 3 + 6 + 6))
+5 * 2 + 7 + 3 * (9 + 9 * 9 * 9 * (4 * 4)) * 2
+4 + 6 + 3 + (2 + 2 * 7 * 2) + 5 + 7
+7 * 9 * 9 * 2 * 4 + 7
+6 + (6 + 5 + 5) + 7 + 4
+9 + (9 * (7 * 3 + 9 + 7 + 8 * 8) * 6 * 5) + 2 * 5
+8 + 6 * 8
+8 * (9 * 6 + 4 + 8 + 8)
+((8 + 3) + 8 * 2) + (3 * 6 * 7 + 7 + 4 + 2) * 9 * 5
+6 * (4 * 5 + 6 * 7 * 4) + (2 * 8 + 4 + 7 + 7 + 6) + 9 + 5
+9 * 8 * (2 + 7 + 9 + 4 + 5) + (8 * (3 * 8 + 3 * 6)) + ((7 * 2) * 7) + 2
+9 + 4 + 9 * 2 * (5 * 2 + 6 + (9 * 5 + 8 + 2 * 5) + 6 + 6) + 7
+9 + 9 * ((3 * 6) + (5 + 5 + 7 * 9 * 4 + 9) + 2 * 6 * 6) * 5
+(9 * (3 * 2) + 8 * 2) * (6 * (8 + 3 * 8 + 5 * 5 * 9) + 4 + 9 * 6) * 5 + 9 * 6
+7 * 9 * (2 * 9 + 4 * (3 * 2 * 6 * 9 + 5 + 6) + 2) + 7 * 6 + 3
+9 + (5 * (3 * 9) + 4 * 6 + 6) + 9 + 8 * 5
+8 + 8 * 8 + (9 + 4 * (5 + 3 * 8 * 3 * 4 * 4) + 2 * 8 * (9 * 6 * 4 * 6 + 9))
+(6 + 6 * 3 + (5 + 8 * 4 + 4) + 3) * (3 + 7) * (6 + 5 * 4 * 6 + 6 + (5 * 7))
+(9 + 7 + 6 + (8 * 8) * 4 * 6) + 3 * 5
+5 * 2 * 3 + (3 + (6 + 9 * 2) * 3 * 3)
+2 + (8 * 7 * (4 * 8 * 2 + 6 * 7)) * 5 + 5 + (8 * 5)
+9 * 6 * 4 * 2 * ((6 * 3 + 9 * 8) * 5) * 3
+((8 + 6) + 6 * (8 * 5 * 5 * 7) + (2 + 9 + 6 * 7) * 7 * (2 + 9 * 7 * 3)) * ((7 * 5 + 2 * 5) + (8 * 7))
+(7 + 8) * 6 * 9 + 6 + 6 * 8
+7 * 8 + (8 * 2) * 7 * 8 * 9
+9 * ((8 + 6 * 9 + 2 + 3 * 2) * 2 + 4 + 3 + 7) * 2 * 6
+2 + (8 + (2 + 9) * 7 * 4 + (8 * 6 + 8 * 6 * 4 + 5) + 6) + 4 * (9 + (3 + 4) * (3 * 9 * 7 * 6 + 9 + 7) + 9 * 6 * 3)
+2 + (8 + (8 * 2 + 3 * 8 * 4 + 2)) + 3 * 6
+(5 * 5 + (3 + 5 * 6 * 9 + 4 * 4)) * 8 * (7 * 7 + 3 * 7)
+9 + 6 * (9 * 2 + 2 * (9 + 6 * 8 + 5 + 3))
+5 * 5 + 5 * (7 * 3 * 3 * 5) + 6
+7 * 5 * 7 * ((6 * 3 + 5 * 8 * 6) * 7 + 4 * 5) + 7
+(5 * 4 + 8) * 3 + 6 + 9 + 6
+(7 + 7 + 4 + 8) * (2 * 7 + 9) * 2 * 4
+2 + ((7 + 2 + 9 * 4 + 2) * 6 + 9)
+9 + 2 + (7 + 6 + 4) * 3 * 8
+5 + 7 * 2 + 2 * (3 * 4 + 4 * 6) + 2
+2 + (7 + 2 + (9 * 3 * 5 + 7 + 7) + 5 * (7 + 7 * 2 * 4 * 7 * 4) + 5) * (6 + 2 * 5 + (4 * 6 + 4 * 8 * 4) + 7) * 2 * 5
+((5 * 9) * 9) * 2 + 4 + ((3 + 6) + (9 + 3 + 6 + 3) * 3 * 5 + (9 + 9 + 6 * 7) + 7) * 2 + 9
+4 + (4 + 4 + 6) + 6 + 5 * 9 + 8
+(3 * 8 * (7 * 5 * 7 * 5 * 7 + 2)) * 7 * 4 + 3 + 2 + 4
+(4 * 8 + 7 + 8 * 5 * 9) + 2 * (5 * 2 * 3 * 9) + 7 + 7 * 2
+6 * 3 * (4 + 6) + 7 + 2
+(5 + 4 + 4 * 8 + (4 * 6 * 5 + 7 * 4 * 2)) * 9 * 6 * 6 * (3 + 5 + 9 * 7)
+4 * (5 * 2 + 8 * 9 * 3) + 3
+7 * 3 + 7 + 5 + ((6 * 8 * 8 + 8 + 2 * 4) * 8 * 2 * 9)
+4 * 2 + 6 + 2
+(2 * 2 + 2 * 9 * 6) + (5 + 9) * 3 * 9 * 5
+(5 + 5 * (3 + 3 + 7) * (3 * 7 * 7)) + 4
+9 + 7 + 9 + 5 * 6
+(6 + 9 + (4 + 7 * 7 * 4) + (9 * 2 + 9 + 5 + 6)) + 7 * 8
+5 + (5 * (6 * 5 + 8 + 2) + (4 * 7 * 4 * 7 * 7 * 8) * 8)
+4 + (6 + 6 * 2 + 9) + 7 * ((3 + 8) * (3 * 5 + 5 * 3 * 3 * 6) + (4 + 9 * 3 + 3 * 2 + 9))
+(7 * (7 + 7 + 5) * 8 * 2 * 8 + 3) + (2 * 4 + 8 * 7 + 3 + 2) + 7 * (7 + 2 + 2)
+(3 * 7 * 4) * 5 + 4 * 7 * 8 * 4
+7 * 3 * (2 * 7 * 9 * 7 * (8 + 4 + 2) * 3) + 7
+7 * (9 + 2 + 5 + 5 + 7 * 5)
+5 + 2 * 9 * (8 * 6 * 8 + 2 * 7)
+4 + (2 + (2 * 5 * 7 * 5) + 3 + 6) + 8 * ((3 + 4 * 4 + 5 * 3 + 6) + 2 + (5 * 8)) + 8 + 3
+2 * (9 * 7 * 3) + (8 + 7 + 8 + 2 * 3 + 9) + 8 + 9
+8 * (7 + 5 * 3 + (2 * 6 * 6 * 4) + 9) + 3 * 4
+3 + 4 * 8 * 9 + (6 + (5 + 7 * 7 * 4)) + 7
+(5 + 6 + 8 + 5 * 7) * 2 + 5 * (9 * (9 * 9 + 8 + 5) + 7 * 4)
+8 + (8 * 2 * 4 * 2 + 3 * 2) * (3 * 3) * 6 + 8
+(6 * 2 * (6 + 5 * 9 * 3) * 6 * 2 + 7) + 7 * 8 + 2 * 4
+5 + (2 + 4 + 5 * 4 + 6) + 9 * (5 * (5 + 9) * 9 * 9 * 2 + 8) * 5
+7 * 4 + 9 * (9 + (5 * 7 + 8 * 7 * 5) + 9 + 2 + 2 + (2 * 4 * 7 + 5))
+7 + 2 + (4 + (8 + 8 + 5 * 9)) + 9
+(8 * 3 * 9 + 6) * 8 + 8 + 7
+(2 + 3 * 9 * 4) * 7 + (8 * 6 * 9) * (8 + 6 + 9 + 4)
+((7 * 6 + 4) + 6 + 6) + 5 * 4 + 3 * 4
+5 * (2 + (3 * 9 + 9 * 6) + (7 + 3 + 2 * 4 + 9)) + 7 + 8 * 5 * 5
+7 * 9 * (5 + 6 + (7 * 6) + 4 + 4 + 3) * 2 + 9
+(3 * 2 + 5) * 8 * (2 + 4 + 2 + 8 + 7 * (8 * 9))
+((2 + 7 * 8 * 9) * 4 * 3 + 6 * 7) + 9 * 8 + 5 + 9
+5 + 4 + 9 + 8
+7 + 7 + 9 + 2 + 5 + ((6 * 3 + 3 + 6) * 4 * (4 + 4))
+(9 * 4) + 8 * 4
+3 * 9 * (9 + 5 * 4) + 8 + 9 * 3
+3 + (9 * 8 * (6 + 4 + 6 + 5 * 2) + 9 + (4 * 7 * 7) + (3 + 4 + 6 * 8 + 9)) * (2 + 8) + 7 * 5 * 6
+9 + 6
+6 * 8 * 8 + 6 * 6 * ((9 + 3) + (4 + 2 * 8 + 8 * 2 + 5) * 2)
+4 + (4 * (2 + 2)) + 7 + 4 + (4 * (8 + 8 + 4 + 4 + 2) + (3 + 2) * 9 + 8) + (4 + 9 * 9)
+(2 * (3 * 7 + 6 + 2)) + (4 * 6) + 6 + (6 + 9 + (2 * 2 * 2 + 6 + 4) * 4) * 5 + (4 + 2 * 5 * 8 + 6 * 2)
+4 * ((5 + 5 + 9 + 3 * 5) * 7 * (7 + 9 * 5 * 7 + 2) + 5 * (4 + 7)) + 7 * 9 * 6 * 4
+4 * 7 + 4 + ((4 + 8 * 6 * 3 + 2) + 3 + 8 * (6 * 7 * 2 * 8) * 7) * 9 + 6
+4 * 6 * ((3 * 6) + 4 + (2 * 2 * 2 * 7) + 9 + 8) * (3 + 8 * 2 * 4 * 2 * 3) + (4 + 3 * (7 + 5) + 6 + 9) + 5
+(7 + 2 + (8 + 6 * 4)) + 8 + (7 + 5 + (2 * 5 + 9) * 5)
+(7 * 8 + 5 + 8 + 8 * 2) * 6 + (5 + (8 + 3 + 4 * 5) * 9)
+8 * (4 + 5 * 9 + 6 + 8 * 7) * 3 * 6 + 4 * 5
+6 + ((6 * 3 * 4) + (8 * 8 * 2 * 5 * 8 + 2)) + 3
+9 * 3 + 6 + 5 + ((5 * 2 + 9 * 5 + 6) + (4 * 9)) + (4 * 2 * 3 + 7)
+6 + 8 + (6 + 2 + 8 + 2) * (5 + 8 + 5 * 5 + (4 + 9 + 3))
+(2 * 7) + (6 + 4 + (8 + 6 + 5 + 9 * 4 + 7))
+8 * 3 + 3 * (3 * 5) * 6 + 2
+9 + 4 + ((5 * 4 + 2 + 6) + 5) * 5 + 6 + 4
+(9 * 9 * 3 + 5 * 3 * 4) * 3 + (2 + 3 * 5 + (3 + 6 * 6 + 2) * 8 + 3)
+(6 + 9 * 9 + 7 * 6) + 7
+4 + 6 * (3 * 3 * 7 * 7 * 5 + 2) * (7 + 7 * 2 * 5 + 4 + 9) + (8 * 2 + (8 + 8 * 4 + 7 + 3 + 5) * 7) + 9
+4 + 8 + 6 * 7 * 7 + (2 * 8 + 3 + 5)
+4 * 8 * 4 * (9 * 9 * 5) + 9
+8 * 5 + (2 + 3 + 2 + 8 * (3 + 5 + 8 + 7 * 9))
+3 * ((8 * 6 + 9 * 8 * 5) + 9 * 6 + 6) * 6
+5 * 8 + 6 * (5 * 2 * 8)
+8 + (6 + 7 + 7 * (6 + 7 + 3) * (5 + 2 * 7) + 7) + (2 * 8)
+6 + 5 + 4 + 2 + ((3 + 8) * (5 + 4 * 9) * (4 + 9 + 3 + 9 + 9 * 7) + (5 + 2 + 9 + 3) + (6 + 6) + 3)
+3 * (2 + 5 * (5 * 6 * 5 + 9) + 9 * 5) * 8 * 5 + 4
+2 * 4 + 6 + (9 * 4 * 3 * 4)
+(4 * 6 * (3 + 9) + (3 * 5 + 8 * 5 * 9) + 6) + 9 + 8
+(3 * 5 + 8) + 8 * 8 * 7 + 8 * (9 + 6)
+(5 * 4 * 6 + 3 + 3) * (3 * 8 * (7 + 2 * 9 * 6)) + ((9 * 9 * 4 + 8 * 7 * 7) + 4 * 4) + 8 * 6
+3 + 5 * 5 * 6 * ((3 + 3) * 8 + (6 + 9 + 2 + 6 * 7)) * 4
+9 + ((4 * 7 + 2 + 2 * 6) + 8 * (4 * 6 + 7 * 5) * 7 + 4) + 6 + 6
+(9 + 9 * (8 * 2 + 9 + 5) * 3 * 4 * 4) + 5 * ((3 + 6 * 3 * 7) + 6 * 4) * (3 + 8 * 9 + 6 + (4 + 3 * 4 + 2) + 6)
+5 * 5 * (9 + 8 * 3 * 3 + 3) * 4 + 8
+3 + (6 * 9 * 8) + 9 + (3 + 3 + 2 + 5 + 2)
+3 + 4 * (4 * 8 + 2 * (3 + 3 + 4 + 9 * 7) + 4 + (6 + 9 + 4 * 6 + 9))
+6 * 5 * 9 * ((6 + 9 * 6 + 7) + (6 * 4 + 2 * 4 * 6 * 6) + 9 + 6 + 8)
+7 + 7 * 2 * 4 + 7 * 2
+2 + 8 * (7 + 3 * 3 + 2) + 6 + 3 * 7
+2 * 2 * 9 + 8 + 8
+9 + 5 + 4 * (6 * 7 * 5 * 7 * 4 * 3) * 3
+7 * 5 * 7 * 6 + 4 * 9
+((9 + 7 + 9 + 7 * 7 * 4) * 6 * 5) + 5 + (8 + (2 + 6 * 9 * 7 * 9 + 9) * (9 * 3 * 8 + 9 * 6 * 2) + 6 * 7) * (2 + 6 + (3 * 4 + 4) * 6 * 5) * 9 * 5
+(7 * 5 * (3 + 2 + 6 * 5 + 9) + 5 + (2 + 9) + 2) + 2 * 6 + (5 * (7 * 2 + 3 + 8 * 9) * 7 + 6 + 6 * (5 + 3 + 9)) * (4 * 6 + (9 + 7 + 4))
+((3 + 5) + 7 + 3) + 6
+3 * 4 + 4 * 6 + (5 + 8 * 2)
+7 + (7 * (4 + 4)) * 3 + 7 * 4
+(5 + 4 * 6 + 3 * 9 + 7) * (7 * 3 * 5) + 6
+3 + 4 * (8 + 2) + ((6 * 7) + 8 + 8 * (9 * 3 + 2) * 9)
+7 + (7 + 9 * 2 * 9 * 2 * (2 + 5 + 9 * 6)) * 4
+(7 + 6 + 3 + 5 * 2) + 2 * 3 + 4 * (3 + 4 * 5 * (3 + 7) + (7 + 2 * 7 * 6) + 8) * 8
+4 + (9 * 2 * 6 * (6 + 6 * 7 * 7 + 5) * 9) * 9 + (4 + 8 * 7) * 4 + 4
+6 * 6 * 2 + (4 * 2 + 7 + 4 + (2 + 2 * 5)) + 2
+8 + 2 + 3 + 3 + 8 + (6 + 4)
+8 + 9 + 2 + ((3 * 9 * 3 * 5) * 3 + (2 + 2 + 8 + 6 + 9 + 7)) + 9
+6 * (3 * (5 * 4 + 4 * 4 * 4 + 4)) * 8 * (5 + (5 + 2 * 7 + 8) * 3)
+3 + ((3 + 7) + 2 + (5 * 3 + 4 * 9))
+4 + 5 * 6 * (7 * 5 + 6 * 5 * 5 + (4 * 6 * 9 * 6)) + 7 + 3
+7 * 4 * 7 * 5 * (3 + (5 + 6 + 9 * 9 * 3 * 7) * 2 * 8 + 2 + 6)
+5 * 4 + (4 * 7 * (3 + 8 + 9)) + 4
+(7 + (3 * 5 * 7 + 5 * 8) * (6 + 9 * 6 * 7) * (3 + 9 * 8 + 4) + 8 + 7) * 2 + 4
+8 + 7 + (9 + 6 + 7 + 9 + 6 + 4) + (7 * 8 * 6 * 5 * 3) + (3 * 4 * 3 * 8)
+7 * ((4 + 4 + 9 + 3 * 3) + (9 * 6 * 8 * 7 * 3 + 6) * 7 + (7 + 2 * 3 + 6 * 2)) + 3 + (5 * 8) + (4 + 9 * 6 * (2 * 5 + 7 * 3 * 5) * 3 * 8)
+8 + (3 + (8 + 3 * 4 + 4)) * 2 * 4 * (3 + 4)
+(4 + 9 + 4 + (4 + 7 * 3 * 2 * 5 + 7)) * 2
+2 * 8
+6 * (7 * 5 + (4 * 5 * 2))
+(3 + 3 * 4 * 3 + 7 + 4) + 8 + 2 + 4 * 4 * 5
+7 * 2 * 5 + (2 * (9 + 6) * (3 * 8 + 4) + 3) * 9
+(6 * 9 * (6 + 6 + 7 + 7) * (5 * 7 + 8 * 5 + 2 * 8) + 5 + 8) * 9 * 9 + 3 * 2 + 7
+(2 * 3 + 8 + (4 * 2 + 7 * 2 + 7 + 7) + 3 + 6) * 3 * (6 + (9 + 7 * 2 + 2) + 6) + (4 + 3) * 3
+4 * (6 * (8 * 8 + 7) + 7) * 6 * 9 * (4 * (6 * 4 * 3 * 2 + 6) + (8 * 9) + (9 + 3) * 4)
+5 * 7 * 2 * (2 * 2 * 5 * (8 + 6))
+(8 * (7 + 7 + 8)) + 2 + 9 * 9 + 9 * 4
+6 + 6 + 5 + (2 * (8 * 7 + 3 * 6) + 9) * 7 + 6
+8 + 6 + (8 * 4 * 8 * 2 + (6 * 6 + 9 * 3 + 6)) + 3
+9 * 5 * 4 * (5 + (3 + 7) + (4 + 4 * 5 + 5 * 8 * 9) * 5)
+5 + 4 * 9 * ((2 * 4 + 8 * 2 * 7 + 2) + 4) * 9 * 3
+3 + 6 * (6 + 2 + 3 * 2) + (3 + 5) + ((3 * 6 + 5 + 7 + 8 * 8) * 9 + (5 + 8 * 7 + 6 * 8 + 7) + 7 + 8 + 5)
+7 * ((7 + 5 * 3 * 5 + 4) + 7 + (6 * 3 * 6 * 6 * 7 * 7))
+((5 + 7 * 9 * 2 + 3) * 2 + 9 * 3) * (4 + 6) * (4 * 7 * (9 + 6 * 8 + 5) * (3 + 8 + 9) + 9 * (8 + 6 * 9 + 6)) * 6 + 4
+2 * (6 * 3 + 4 + 4 * 2) + 6 + 7 + 5
+2 + 7 + 5 + 5 * ((7 * 6 + 2) * 8 * 8) + (2 * 5 * 4 * 5)
+3 + (7 * 8 * 5) + 5 + (5 + (4 * 4 + 7 + 2) + 6 + (8 + 3) * 9 + 4)
+6 * (9 + 5 + 6) * 5 + 5 * (7 * (3 * 5 + 6 + 2 * 5) * 2)
+(9 + 6 + (9 + 7 * 5 + 6 * 7) * 7 * 3) + 3 + 4 + 6
+7 * ((5 + 4 + 6) + 7) + 2 * 3 + (6 + 9 * (6 * 4 * 8 * 3 + 4 * 2) + 7) + 3
+7 * (8 + 9 + 5 * (9 * 7 * 9) + 2) + (7 + 7 + (7 + 3 + 2 * 2) + 4 * 2)
+3 * (2 * (4 + 6) * 8)
+8 + ((6 * 4 * 8 + 4) + 7) * 7
+(7 + (2 + 8 * 8 * 6 * 2)) + 7 * 2
+(4 * 2 + 4 * 8 + 4) + (3 * 9 + (2 * 4 + 2 * 7) * 9 + 7) * (5 + 9) * (7 + (3 * 4 * 4 * 6) + 8 * 7) + 8 + 8
+8 + (2 + 2 * 8 * 7 + 7) + 2 + 4 * 3 + (8 + 9 * 9)
+3 + 2 + 8 + (9 + 3 * (3 + 2 + 9 + 7) + 4 * 4 * 7) * 3
+5 * 4 * 7 * 3 + (9 * (6 * 6 + 2 * 4) * 8 + 2 * 9)
+4 * 7 * (3 + 6 * 6 + 4 + 8) + 5
+(8 + (8 + 2 * 9 + 3 * 3) * 8 * 8 * (9 * 6 + 2 * 6)) * 9 + 5 * 2 + 5
+5 + 6 + 3 + 4 * 9 + (4 + (4 + 3 + 9 * 2) + 4)
+3 * (5 + 3) * 7 + 6
+((3 * 2 + 2 * 6 + 5 + 3) + 4) + (4 * (8 + 2 + 9 * 2) * 8 + (8 * 3 + 6 + 2 + 6) * 2) + 7 + 2 * 9
+6 * 8 * ((8 * 8 + 3 * 7 + 8 * 4) * 4 + 9) + (8 * 7 * (6 * 8 * 3 * 2) * 3) * 2 * 8
+(2 * 7 + 4) * 2 * (5 * 4 + 2 + 5 + (7 + 5) * (4 * 3 + 6 * 8 * 5 + 9)) * 5
+(6 * 8) * (7 * 7 + 8 * 3 * 3) * (5 * 8 + 2)
+(6 + 6 * 2) * 5 + ((7 * 6 * 8) * 8 * 9 * 4)
+(8 * 4 * 9) + ((5 * 3 + 6 * 3) + (9 + 9 + 9 * 2 * 2) * (4 + 9 * 7 + 2 * 2 + 3) + 6) * 7 * 6 * 6
+((4 + 3) * (2 * 5 + 8 * 2 * 4) * 9) + 6 + (6 + (5 * 4 * 5 * 3 + 3) * 6 * (5 * 3 + 7 * 2 + 4 + 8)) + 4 + 7
+(6 * 9 + 9 + 7) * (6 * 2 * (4 * 7 * 4 + 4 * 5 + 7) + (7 + 5 * 8 * 4 + 9 + 6)) * 7 + 8 * 5 + (9 * 5 * 2 + 7)
+6 * 6 + ((2 + 9) * 5 + 2 * 3 + 3 * 3) + 9 * ((4 * 7) + 5 + 8 + 4)
+5 + (4 * 5 + 5 * 3 + 7) * 6 * 5 + (2 + (9 + 7 + 8 + 4))
+(2 * 4 + 5 + 8 + 6 * 9) + 3 + 6
+9 + (9 + 8 * 3) * (3 + 8 + 6 + 5) * 5
+(3 + 9 * 5 + 7) + 2
+((9 + 5 * 2) * 5 + (4 + 2 * 7) + 9) * 8
+(4 + 4) * 9 + 3 + 2 * 8
+(3 + 4 * 8 + 9 * 6 + 6) * 5 + 8 + 9
+3 * 8 + 9 * (3 * 4)
+6 + 7 * 6 * 7
+3 * 3 + (8 * 8 * 9 + 3 * 8 + 2) * 3 + 8 * 2
+5 + ((6 + 2 * 6) * 8 + 6 * 5) + ((7 + 3) + 2 * 5 + 7 + 6 + 5) + (8 + 2 * 7 + 4 + 2 * 3) * 2 * 5
+(6 * (6 * 7) * 7 + 3) * 9 + 6 * 3
+(5 * 9 + 7) + 8
+(3 + 9 * 3 * 9 * 2) * 9 * 5
+5 + (6 * 3)
--- a/input/day18_example.txt
+++ b/input/day18_example.txt
@@ -0,0 +1,7 @@
+1 + (2 * 3) + (4 * (5 + 6))
+1 + 2 * 3 + 4 * 5 + 6
+2 * 3 + (4 * 5)
+5 + (8 * 3 + 9 + 3 * 4 * 3)
+5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))
+((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2
+6 * ((3 + 4 * 3 * 7 * 8) * 8 + (9 + 5 + 2 * 3) * 3 * 2) + 7 + 8 * 8 + 4
--- a/input/day19.txt
+++ b/input/day19.txt
@@ -0,0 +1,578 @@
+77: 30 112 | 20 13
+121: 43 20 | 123 30
+42: 57 30 | 101 20
+30: "a"
+50: 65 20 | 134 30
+37: 89 20 | 43 30
+106: 16 30 | 54 20
+17: 30 84 | 20 35
+129: 89 20 | 96 30
+123: 30 30 | 20 95
+20: "b"
+115: 20 70 | 30 93
+112: 30 90 | 20 123
+4: 20 55 | 30 5
+72: 20 90 | 30 123
+51: 30 20 | 20 95
+24: 131 30 | 7 20
+94: 121 20 | 15 30
+117: 133 30 | 102 20
+92: 28 20 | 43 30
+70: 87 30 | 96 20
+88: 109 20 | 36 30
+35: 20 36 | 30 61
+96: 30 95 | 20 20
+47: 96 20 | 66 30
+6: 20 55 | 30 123
+130: 30 29 | 20 88
+68: 5 20 | 89 30
+66: 95 95
+75: 96 30 | 55 20
+3: 20 90 | 30 5
+7: 20 53 | 30 123
+86: 30 5 | 20 53
+105: 20 87
+46: 134 20 | 87 30
+102: 30 111 | 20 103
+93: 87 20 | 87 30
+79: 116 20 | 71 30
+8: 42
+33: 5 20 | 87 30
+107: 96 20 | 123 30
+90: 20 30
+110: 20 59 | 30 32
+16: 30 68 | 20 39
+52: 4 20 | 38 30
+71: 96 30 | 51 20
+38: 96 20 | 90 30
+28: 20 30 | 30 30
+27: 30 64 | 20 24
+91: 30 27 | 20 113
+1: 20 90 | 30 134
+54: 105 20 | 18 30
+0: 8 11
+73: 65 20 | 55 30
+132: 30 17 | 20 19
+41: 20 51 | 30 22
+45: 22 30 | 53 20
+14: 124 20 | 73 30
+22: 30 30
+23: 87 30 | 55 20
+10: 30 89 | 20 134
+120: 56 30 | 9 20
+11: 42 31
+109: 95 134
+127: 30 53 | 20 123
+61: 20 53 | 30 90
+103: 127 30 | 23 20
+116: 90 20 | 87 30
+134: 20 20 | 30 20
+114: 20 63 | 30 41
+64: 20 118 | 30 25
+12: 30 48 | 20 3
+111: 20 23 | 30 72
+60: 79 30 | 120 20
+59: 20 28 | 30 87
+65: 20 30 | 20 20
+44: 89 30 | 28 20
+18: 65 20 | 43 30
+32: 95 123
+83: 30 66 | 20 22
+63: 20 123 | 30 55
+48: 30 134 | 20 43
+99: 20 12 | 30 125
+43: 20 20
+133: 20 100 | 30 110
+80: 20 50 | 30 44
+125: 20 98 | 30 86
+135: 128 30 | 130 20
+131: 20 55 | 30 134
+122: 97 30 | 60 20
+25: 30 43 | 20 51
+95: 20 | 30
+55: 30 95 | 20 30
+13: 43 20 | 43 30
+21: 20 76 | 30 80
+98: 89 30 | 65 20
+81: 106 30 | 85 20
+53: 30 30 | 20 20
+78: 45 30 | 37 20
+89: 20 30 | 30 20
+9: 96 30 | 43 20
+31: 2 20 | 82 30
+56: 5 20 | 96 30
+76: 1 20 | 23 30
+62: 92 30 | 10 20
+58: 30 22 | 20 43
+85: 77 20 | 67 30
+26: 30 58 | 20 6
+101: 30 81 | 20 91
+29: 83 30 | 47 20
+126: 20 53 | 30 55
+2: 122 20 | 135 30
+15: 5 30 | 51 20
+34: 20 37 | 30 116
+82: 30 104 | 20 132
+19: 40 20 | 62 30
+108: 21 20 | 119 30
+36: 30 22 | 20 87
+104: 69 30 | 99 20
+100: 20 7 | 30 61
+39: 89 20
+87: 30 20
+113: 52 30 | 34 20
+5: 30 30 | 30 20
+40: 4 30 | 107 20
+97: 20 26 | 30 78
+67: 30 131 | 20 126
+118: 20 134 | 30 66
+124: 96 30 | 22 20
+128: 30 114 | 20 14
+119: 30 49 | 20 74
+84: 129 30 | 33 20
+74: 30 6 | 20 46
+49: 30 38 | 20 75
+57: 117 30 | 108 20
+69: 20 94 | 30 115
+
+aaabbaababbababbabaabbbaaabbbbaa
+baabaabaaaabbabbbbbaaabb
+aabbbaaabaaaabbbbaabbaaa
+bababbbabbabbaaaaabababbbbaaaaaaaaabbaabaaaaabababaaabbaababbaab
+baababbbbbbaaaababaaaababbabbaaaaabbbbbbbabaabaaaaabbbbb
+abbaaabababbaaaabbaabababbbabbaa
+aaabaaabaaabaaaaaaabbbab
+abaaabaabbababababaaabba
+aabbbbbbaaabbaaaabbabbbb
+aabbbabaaaababaabbbababb
+aaabbabbbaabbabbabaabbba
+bbbaaaabbbabbbaaababbaabaaabaaaabbbbabba
+babbbbaaaaabaaaabaaababbbabbaabbbaababbaabaaabab
+aabaaaaabbaaaaaabbababbbbabaaaaabbaaaabb
+bbbbababaaabbaaaaababbaa
+baabaaabbbbbababababaabbaaabbabbaabbbaab
+bbaabbabbbabbbaababbbbbabaabaabbbababababaaabaaa
+baabbbbbaaaabbbabbbbbbbb
+bbabbaabbbabbaaabbbaabaabaaabbbbaababaaa
+babbbaababbbabbababaabbb
+aabbbbbabbbbaaaabbbaabababababbb
+aabbabaababababababbaaabaaabaabb
+aabababbaaaaaaaababbbbaaabaaaaaa
+abbbababaaabbaabababababbaaabbbbaaabaabb
+baabbabaaabaaaaabbbbbaabababaaaa
+abbbbabbbababbababbaabbbbaaaabba
+abababbababaaabbabaabbbb
+aaaabbbaaaaaabaabaaabbba
+bbaabaababaaaabbaaaaaabb
+aaabbabbaabaabbbaabbaaba
+aaaaabaabbaabaababbabaaa
+bbabbbbabbbaabbbabbbbaab
+aaabbabbbaaabbbbbaabaabbbabababbaaaaaababbbbaabb
+abaabbabbabaaabababaababaabbabbbabbbbaaaaabbbbaabbaaaaababbbabbaabbbbbabaabaabbabbbbbaabaaaabbab
+bbbaababaaaabababaaaaaab
+bbbbabbbaaababbbaabbbbbb
+babbbaabaababbbaabbbbbaa
+abababbabbbabbabbbbabaaa
+abaabaaaaabaabbabaaabbbbbbababab
+abababbaaabababbbababaaa
+baaabbabbbbbbabababbaaababbbbabbbaababbbaabbbbabbbaaabbabbbbbbab
+aababbbaabababaaaaaaabab
+baaabbababbaaaababbabbbabaaabaaabaabbbbaaabbabaabbbaabbbabbabbabaabbaaab
+baaaabaabbababbbbbbbbababaaabaab
+bbabbaababbabaabaaabaaabaaaabbaaabbbbaab
+bbbaaaaaabbaaaaabaaaaaaa
+bbabbbaababbbaaaababababbbaabaabbbbbababbaaabbbaabbaaaabbaaaaaaa
+abbbbabbaabbabbbaaaaabba
+babbababbaaabbabbabbaabaaaaaaaba
+bbbbababbababbbbabbababbaaababab
+abbaaaababbabbbbbabbaaabaababaab
+aabbbbbbabaabababbbabaaa
+aaaaaaaababaaabaabaabbaaabbabbbaabaaaaaabbaabbba
+abbbababaaaaabaaaababbbaaaabbaaa
+bbbbbabbaabaaaaaaabaabbaaaaabbaa
+ababbabababbbaabababbbaaabaabbbb
+ababaabaabbabbbabbbabbbabbaaaababaabbaaa
+ababaabaaaababbbbaaaabaabababbaaabbababb
+aaabbbaabaabbbbbbaaababbaaaabbbabbbbbbbb
+aaababbbaaaabaabbababaab
+aabbbabaababbbabbaaaabab
+abaabbbbbbabaabaaababababbbabaabbaabbaabaabababbabbaaaababaaaaaa
+abbaaaababaaaabaabbbbbabbbaaabaaaabbabaa
+babaaaaabbbaabababaaabbb
+abbbbbbaabaabaaabbaaaaaabbabbbaabbabbbbbaabbbbababbababb
+baabbababbbabbababbbbbaa
+bbabaababbbabbabaabbbaab
+ababbbabbbbbabaabaaaaabb
+babbbbbbbaaaabbbabbbbaba
+babbabaabaaabbababaababaababaaab
+aaaababaaaababaaabbbabbaabbaaaabaaaabbab
+abbaabbbbbabbabbababbbbbbbbabbaabaaaababbbbaabbabaaaabbbbabaaaabaaaabbab
+baabbbbabaabbbbabaaabaaa
+aaabbaaaaaabbabaabaaaaab
+abbabaabbaaababbaabbabab
+aabaabbbbaababbabbbbbaaabbbaaabb
+aaaaaaaaaabbabbbaabaaabbabaaabababbbaababbaaabababbbbaaaaaabbbababaaaaaa
+babbabababaaaababaaaabba
+abbaaaaaaaabbaaabbbaabaaabaaaabbabaabaaabbbaabbbbbbaabbbbbaabababababaab
+bbabaababaabbabbbbaaaaba
+bbabbbaaaabaaabbbbbabbbaaabbbbba
+babbbaaaaabbaaaababbbabb
+bababbabbbaabaabbbbaaaaabaabbbab
+bbbaaaaabababbaabaaaaaab
+babababbbaabaaaaaaaabbbaabbbabbb
+aaaaabaabbabbababbaabbba
+aabababbabbabbaabbbaabbb
+baaababbaabbaaaaaabbbabb
+bbaababbaaabbbaababababbaabbaaabaaababab
+baaaabaaababababaabbabbbabababbaaababbbbbbbaabba
+babbbbabbbabbababaabaaabbbbaaaabababaaab
+baaaaabaaabbbbaaabbaabbaabaabbbabababbabbaaabaaaaaabaaababaabbabbabaaaaaaaabbbbb
+babbbaaaabbbbbbbaaaababbaabbbbbbbbbaaaabbbabbbbabaababaa
+baabbbbbabababbaabababaabaabaabaaababbbbbbaabbaa
+babaaababaaaaabaaabaabbabaaabbabbaaaabaabbbaabbbbbabaaabaaaaabbabbbabaab
+abbabaaababaabaaabaaabaaababbbaababbababbaaabaaababbaaaa
+ababaabaabbababaaaabbbbb
+baababbabaabbbbbbbbaabaaababaaabbbbbbbaa
+aabbaaabbbbababbababbaaa
+babaabbabbbbbabbabbbbaba
+abbbabbbbaaababbabaabbaabbbabaaa
+babbbaaabaaaabaaaaabaaabbaaabbbbbabbaabaabaaabba
+bbbbabbbbabbaababbabbbbb
+bbbbaaaabaabbbabbbbabbaaaabbbaab
+babbbbbababababaaaaabaaa
+babbaabbbabaabbababaaaab
+abbbabbabbababbbaabbbbaa
+aaabbaababbbabbbbbaabaaa
+babbaabaabaabaaaaaaaaaaabababbba
+aabaaaababaaaabaababbbababbbababaabababa
+bbbabbbbaaababbaabbbaaaabbbbbaabbabbbbbaaaabbbbaabbbaabb
+abbabababbabbaaaabaabbba
+abbaaaabbaaaabbabbbababaabbbabaa
+abbaaabbbbaaababbbbaaaabbabbbbbabbbababbaababbab
+baaababbababaababbbbabaaaabbababbaaabaaa
+babbaaabbaabbbbbaabaaaaababbabaabaaabaabaabbbabbbabaabaa
+aaababbbaaaababaababbaab
+baaaabbbbaabbbaaabbaabbb
+babbbaabaabbabababaaaaabaabbaabababaabbb
+abbabbbbabababbababbaabaaaaaaaababbaaabbabbbbbaabbbabbabbbbababb
+baaabbbbabbbaaaabbbaabba
+abababaabaabaabbbbbabbbaaaabbababaabbbaabbababab
+aaaabaababababbaaababbbabbabbaabaabbbbabbbbbbbaaabaaaaaa
+aabaaabababbbaabbbbbbbaa
+aabaaaabbaabaaaaaaaaabba
+babababbaabbbaaaabbaaaba
+abbabbbaaaababaaaabaaaaaaabbbbbbabaaabbb
+bbbaaabaaabaababbbbaabba
+bbabaababbbbbabbaaaababaaabaaaaaabbbbaaabbaabaaa
+aaaababbbababbababbbbbbaaaabaaaaabbaaabaabbbbbaabababaab
+baabbbbbaabaaaababbabbaaaaaabaaa
+bbbbbaabbbbbabaababbbaaabababbbbbbbaaaaaabbbbaba
+ababbaabaabbaabbaaaabbbb
+bbbbbaabaabbbbbbbaaaaaaa
+bbbbbaaabbbbabbbaabaaabbbabaabbb
+bbbbbaabaaababbaaaabbaaabbbbababbabaabbabbbaaabbaaaaabbb
+baabbbaabaabbababbababbabaaaabab
+abaababbabbabbaaababbbba
+aaabbaababbabababababaaabbabbbbb
+aaababbbbabbabaaabaabaaabbbbaaba
+baaababbbabbaaabbaabaaaabbbababb
+abbbbbbaabbbabbaaabaaaabbbababbbaaabbbab
+bbbbbababbbaababbababaab
+aaaababababbbaaaabababbb
+bbabbaababbababaaabaaababbbbababbbbbbbabbbaaabbb
+abbbbbbbaabaabbaaabbbaab
+bbbaababbbbbbaaaaaaabbab
+babbbbbaaaaababbaaaaaabb
+baabbbaabaabbababbabbabb
+baabbababbbaababaabbabba
+baababbabaaabbabbaaababbbabbbbbbbaababbbbabbbabbbababaab
+bbaaabaaaaababbaaaabbbab
+babaabbaabbbbbbbbabaabbb
+ababaabaaaabbbaaabababaaaabaaabbbaaaaabb
+baabbabbaabbaabbaaaabababbabaaab
+aabaabbbaaababbbabbbbaab
+bbbbbaaaaaabbabababbbbaaaabbbabb
+baaabaabbaaabbbabaabaaababaabababbbababababbaaababaabaabbbbabbabaaabbabbaabbaaabaaabaaab
+aabbbbbbaabaaabbbbabbaaabaaaaabaabbbaaaababaabaa
+aaaabaabbababbabbbbabbbbaabbbababbbaaabaababaaaaabbabbab
+babaababaaaabaabbaabaabbbaabbababbabbbbb
+bbbaababbbbaabaaabbbabbbabbaaaba
+baaaabbabbbbaaaaaaaaabbbbbabababbbbababaaababbbabbababababbbbbba
+abbbabaaabaabbbaaabaabaabbbbbbab
+babaaaaabaabaabaaaabaabb
+aabababbabaabaaaaaaabbbabbaabbabaaaabbabbaaabbba
+ababbbabbbbbbaaaaaabbaababbbaaaaaaaaabba
+baabbabbbbabbaababbabbaaabaabbba
+bbaaababbabbabbabbabbaabaaaaaababaabaaabaababaaa
+baabbbbbbbbaabaaabbabaaa
+abbabababaaabbabbaaaabab
+ababbababaabaaabaabbbbbbbbbabaab
+baabababbaaaabbababbaaaaabaabbaa
+abbaaabbabbabbabaaaaabbbbabbbbaaababbbbbaababbabbaababbaabbbabba
+abbbbababbabaabaabbaaaabbaabbabaaabbaababaaabaababaaaabbabababba
+babbaaabbbabbabaaaabbbab
+aabbbaaaabbbbabbaaabbbbb
+baababbbbaaabbababbbabbbbbaaabaaaabbaaaaaaaabbab
+babaabababababbababbbbbaabbabaaa
+babaaabaaaabbabbaabaaababbaabaabbaababbbabaabbbabbbbabbaabbaabaa
+baababbabababbabbbabbaabbaabbbaabbbababb
+baabaabbababaabbaabbaaaaaaaaabba
+aaaababbbabbaababbbbaaba
+bbbabbbaaaaababbaabbbbaa
+abaaaabaaaaaaaaaaaabbaaaabaabbab
+ababbaabbabbaaaabbbbaaab
+baaabbbbabbbaabababaabababaabbbb
+baabaabaaabaaabbbbbaabaaaabaababaabbbbba
+bbbbabaababbbaabaaaaaabbbaaababa
+abbabababaabbabbababbabb
+babababababaaaaaabbbbbaa
+aabbbbbbbabaaaaabbbaaaaaabababbbabbbaabbababbaaa
+babababaabaababaababaaab
+baababbabaabbbbaaaabbbaabaaabbabababaababaaabaabababbbbbbbabababbaaabbaa
+abbbaabaaabbbabaaaabbbbb
+bbabbabaabbabbbaaabbabbbaababbababbabaaa
+abbaababaaababbbabbbbbab
+aaababbababaaabbabbababb
+baaaaabababaaabbbaabbbaabaaabaaa
+aabaaaabbbbbababaaababbb
+abaaaabbbabbabbaabbbbbbbabbaabbb
+bababaaababbbbaaaaaabababaaaababbaabbbabbaaabbabaabaaaaababaaaabaabaabbabbbaaabbaababaab
+aabbabbbabbaaaaaaaababab
+bbbaaaaaababbaabababbbba
+ababababbbababbbaaabbaabbababbbabbaabbaa
+aabbabaabaaabaabaaabaabaaaabaabbbbababbaaaababababbbbbabbbaabaaababbaabababaaaabbaaaaaba
+abbbbabbbbaaaaaabbaabaaa
+aaaababbbabaaabbbabaababaaabaaabaaaaabbb
+ababbbaaabbabbaabbaaabbb
+abaaaabbbaabbbaaaaabaaabbbabbbba
+aaabaaaaaaabbabaabbabbaababbbbbaabaabbbb
+aaabbabbbabbbaababaababbaaaaabbbaababbbb
+aabaabaabaaaabbabaaabbaaabbabaaaaabbabbbbbabaaaabbbababbaabaabbb
+abaabbaababbaaabbabaaabbbabaabbabbabbabaabbbbbabaababbaa
+ababbbabbbbabbbbbaaaabbbabbabbbaaaaaaaab
+abbbabbabaaabbababbbababaaabbaabaaaaabba
+abaaaabababaaaaabbaabaabaababaaa
+bbbbbbabbabbbbaaaaabbbabbbaaaabaaabaabab
+bbbaaaaaabbbbbbbaabababa
+baabaaaabbbabbbaabababbb
+aabbbabaaaaaabaabbbabbaa
+babaaabbaaaaabaaabbbbbbbbabaaabbaaaaabab
+bababbbbbaabbabbbbaaabbb
+bbaabbbaabbabbbbaabbbabb
+abbabaabbabbaabaaababaaa
+bababbaabaabaabbabbabbab
+bbbaababbabbabaabaabbbbabaaaaabbbbbbaaab
+bbbaababbabbbbaabababbba
+babbaabbbabbabaaaabbabbbbabaaaabbbbababb
+bbaabaababaabaaaababaaababaaabbaababbbbb
+abbbabbbaababaaaaaabbabbabababaaaaababaaaaababbabbaababb
+abbaaabbbaabbabbabaabbaaaababbbabbaabaabababbbabaaabbbab
+abbbaaaaaabbbaaabbaaabbb
+bbbbbabbabbabbaaabbabbbb
+baabbabaaaaabababaaaaaab
+aaaababbbbbabbbaaaababaabababbbb
+abbbabaabbbababbbbabbbaaaaaaabaaaaaaabbbaaababab
+baaabbbbaaabbaabbaaabbababbaababbbbaaaba
+bbaababbbbbbbababaaababbabbabbbaaabbbabaabbbabbbbaaabaabaaabaaba
+aaabaaaabbbbabbbbabbbabb
+bbabbaababaababababbabbb
+babbaaababbbbabbabbbaaabaabbabba
+bbabbaabbabbabaababaaaaaaababbabbaaabbaababbbbbaababbbabaababbabbbabbbaabbbabbbbabaabbab
+baabaaaaabaaaabbabbbbbbbaabbbaaabaaabbabbabbabbaaaaaaababaaababaaaaaabbb
+bbaabbabbbaaabaabbaababa
+aababbbabbbaabaaaaabbbab
+baabbbbaabbabbaabbaaaabb
+bbabbaabbaaaabaaaaaabbbb
+baabaabaaabaabbaabababbb
+abaabbaabbaabaabbbaabbabaaabbbaaaaaaabbb
+bbbbbababbaaababbaabbaaa
+bbaabbabbbabbaaabaabbbab
+bbbaaaaaabbbbbbbaabbabaa
+bbaaababbbabaabbaabbaaaaaaabbbbbbaaababaabbbbbbbbabaabaaaabbabab
+aabbaabbbabbaaabaabbaaaabbababab
+abbbabbaaaababbaabbaaaaa
+aaabbabbbbaabaabbbabbaaaabbaaabbbabbbaba
+abaabaaababbababaaababbbaabbbabb
+abaaaabababbbbbbaaabaaaaabababbaaabbbbab
+abbaabbbbbabbbbabbbaaababbabaaabbbabbbab
+babbbbbbbabaabbabaababbaabaabaaaabbbabaababbbbab
+bbbabbbbaabbaaaaabbaabaa
+bbbbbaaababababbbaaababa
+baabbbaabaabbababbbaababbbababbbabaabbbb
+bbaababbbabaaabbabbbaaab
+baabaaaaabbaaaaabbbaaaabbabbabbaaabbbaaaaabaabbbbbbbaaba
+abbbababaaaaabaaababbabb
+aaaaabaababbaaabaaaababbbaaabbbbababaaaa
+ababbaababbabbbababbabbabbabbaababaaaaabbbbbaaaabbbaaaba
+baaabaaabbbbabaaaababbaabbbaaabaababbabbaaabaaba
+bababbaaababababaabbabbbaabaabaaabaaabbaabbbaaaaabbbabaa
+abbaaabbabbaababbbaaaaaabbaaaabb
+bbaabaabbbbaaaaabababababbabbbaaaaabbbba
+bbaababbabbababaabbbaababbabbabbbbabaaab
+abababaaabbbaaaabababbaaabbbaaababaaaaab
+abbabaababbbbabbbbaabbbb
+ababbaabbabbabababaaabbb
+aababbbabababaababbbbbbaababbabbaababbbbbbbbaaaababbaabbbaaaaabb
+abbbaaaaaabababbababbbba
+babbabaaaaabbbaabaaabbaa
+aabaaababaabbbaaaabaaababaaababbabbbaaaaaaaabbaa
+bbaabbabbbabbabaaabbaaba
+bababbaabbbaababbaaaabaaabbbbaab
+bbbabbbabbbabbababbbaaab
+abbbbbbbaabbabbbaaaabaabaabbaaabaaaabbbb
+bbbbbabbbaababbbaabbaaba
+ababababababababababbabb
+baaaaaaabbabbaababaaabbb
+bababbaaabbabababababbabaabaabbabbaababaababbbbb
+bbabbaaabbbbaabaababababaabbbbabbabaabbbbaabbbaabbaaaababaabaabb
+abbababaabaaaabbbabaaaab
+bbabaabababbaabbbabbbbbbabbbbaabaabaabaa
+bababbaaaabaaaaabbbbaabb
+bbaabbabaabaabbbbabaabbaababaaababbaaaab
+babaaabaaabaaaabababaabababbbaba
+babbbbbaabababbaaaabbaabbabbabaabbaabbbb
+abbababaabababaababaaababbbabbaa
+aabaaaaaabbabbaabbabaababaababbaabaaabbb
+abaabbaabbbbbaaaabbaabba
+babaabbabaabbbbbbbabbbaababbbaabbbbababbaabbbaaabababbbbbaaababaabbbabbabbaaaabbaababaabaaaabbba
+aaaabbbabbaaababaaabbaaaabababaababbbbababbaabbb
+baabbabaabbaababaabbabab
+ababaabbaabaaabaabbababb
+aabbbababbaabbabaaaaabaa
+ababaababbbabbbbbaaaabab
+ababaababaaaaababbbabbbaabbbabaa
+abaabbaaabbabababbbbabba
+babbbbbabbaaaaaaaaaaabab
+bbabbababbbabbbbababbbbb
+abaababbabbaaabbbbbbababbbbbaaaa
+abaaaabbbababbbbaababbbb
+baabaababababbbbababbabb
+baaaabaaaaabbabbabbabababaabbababbbbabaaabaaababbabbaaaa
+aaaaaaaabbbabaaabbabbabaaabbbbaaabaaababababbabbabababab
+bbbaaaabaaabaaaaaabaabbbbababaab
+baabbbbabaaaaabaabbbaabb
+abaaaabaabbaaaaaabaababbbaaabbba
+ababbbaabbbaabaaaaababab
+aaababbabbbbbabbabbbaaaabababaab
+bbbbabbbbababbabaabbbbba
+baaabbbbbbbbbaaabbaaabaaabaaabbaaababbab
+bbabbaabababbbbbbbbaaabbabbbaaba
+aaabbababaabaaabbaababbbbbaabbababbaaabbbbabbabbaabbbbab
+abbaaaaabbabbaaaabbababb
+baabaabbbaabbabababbaaabbaaaaababaaaabbabbbbbbaa
+babbaabaaabababbbabbabaaabaaaaabbbaaabbb
+babababbaabbaabbbbbbaaab
+babaaababbbaabaaaaaabaabbbbaaaabababbaaa
+aaabbbbbbbabababaabbabba
+baaabbaaaaabbbbaaababbaaabbaaaaabbabbbbbabbbabbbbbbaaaaabbaaaababaaabbbbbaabbaababbbbbbababbaaaa
+ababbababaabbabaababbbababaababbabbbaaaabbbbbbaaabbababb
+babababababababaaaaabbab
+aaabbaaaabbbbabbabaaabbb
+babbbaaabababbaabaabaabaabbaababaaaabaaaababaaab
+babaaaaaabbbbabbbbaabbba
+bbabbaabaabbbaaaaabaaabaabbbababaabbaabaababaaaaababbbba
+aabbbabaabbabbbababbaaaa
+baaaabaababbabaabbbaabbb
+aaabbabaaaabaaabaabbaaaabbaabbaa
+abaabaaaabbabbaabbaababbabababbabbbbaabbbbaabbba
+bbbaaaaabbabbabaabaaabaa
+ababbbabbabbaababbaabbaa
+aaabbaaaababbbabbaabbaaa
+aaaaabaaabbabbaaabbbbaab
+bbbaaaababaabaaabbbabbbabaabaaaabaabbbaaabbabaabaaaabbbb
+babaaabababbbbbaaaaabbaa
+baabaabbbabaabaabbaaaaab
+baababbbbaaabbabaababbbb
+bbaababbbbababbabbabbbbb
+abbaababaabaabbaabbbbbbbbbaabbbbbbaababa
+babaaaaaaaababbaabaaabab
+babaaaaabbaabbaabaabbaabbbaabaaabbbbaabbbbbaabba
+bbbaaabaaabbbabbabbaabbb
+bbbbabababbaaaaaaabbbaaabbbbabaabbaaaaaabbbbaaaa
+bbbaaaaaabaabaaabaaababa
+aaabbababaaabbabbabaaaaaaaababababbbbaab
+babbbbbabababbababaaabbb
+aabababbaabbabbbbbbbbbba
+abbabbaaabaababbbabbabbaaaaabaabaabbbbba
+babbabbaabababbabababbbbaaababaaabbaaabbaabaabaa
+aaaaaaaabbbabbbaabaaabba
+baaaabaaabbbbbbaaabaabbbbbbbaaaa
+abbbaaaabababaaabbbbbabbabaaabaaaaababbbabaababaabaaaaaa
+abaababbabbbbbbaaabbabbbabbaaaab
+abbabbbababbaaabbbabaaaabaababaaabbaabba
+aaaabaabbbababbbbabbbbaabbbabbababaaaaab
+abbaaabbabaababbbaabaababaaababa
+abababababbaaabbbaaabbababaabaab
+baaabbabaabaabbaaabababa
+bbaaabaaaaaaabaababbaabb
+ababbabaaabbabaaaabababa
+babbbbaabbbbbaabbbaababa
+babaaaababaabbababbabbbaabaaabababbabbaaaabbaabb
+baaababbaaabaaabaabbabbbbaaaaaab
+abaabbaabbabbaabaabababbabbabbbb
+bbbaababaababbbabbababab
+baababbabaaaabaaabababbababaaaab
+babbaababbabaaaaababbaaa
+aababbbaaabababbaabaabab
+bbaabbabaabbbbbbbbababbbaaaabbbabbbbaaba
+bbaaababbbaaabaabbbaaabaababbbbababbbabbababbbbaabaabbba
+bbabaaaaaabbbababbaaabbb
+baaaabaabaabbababaabaaababbbaabbbbabbaabbbbabbabaaababaaaabbaaaaaaaabbabaabbbabaabbabbaa
+abaaaabbaabbabaaaabbbababbabaaaaaabbaaba
+baaaaaabbbabbbbaabbbbbbbbbabaabbbabbabababaabababbbbaaabaaaabbbababbbbaa
+aaaaaaaaaabbbabaaabbaaab
+aababbbababaabbaaaabbbababbbaabb
+abbbbabbaaabbbaaababaabbbabababa
+aaaaabaabaaaabaaabbaabaa
+bababbabbabaababbabbbabb
+abbbbabbbaabbbabbbbaabaabbbaabbaaaaababaaaaaaaaababaaaba
+aabaaababbbaabaabaabaaaabbbbaaababbbbaba
+abbabaabbbaaababaaabaaba
+bbaaababbbbbbaababbbabaa
+bbabaaaababbbaaaabaaaaaa
+aaabbaaabbabaababaaaabba
+baabbabaaabbaaaaabbbbaba
+baabaabababbaabbbbababaa
+aaaabaabbbaaababaabbaabbabbbaaaaabaabaab
+aaababbbaabaaaabbaaaabbbbabbbbba
+aaabbbaababbaababbaaaaba
+bbbabbbababbbaabbbaababa
+abbbaaaabbabbbaaabbaabaa
+aaaaaabbbbabbaaaabbabbbabaabbbabbbaaabaabaaaabaa
+abababaaaaaaaaaaabbbaababaaaabbabbaabbabbabaabaaaabaabaababaabbabaabbbbb
+ababbbaaabaabbaaabaababaabbbbbaa
+abbabbbaababbababbbbbabaaabaabbabaabbabbbbaaaabaabaaabaa
+ababbaabababbbabbbbbaaab
+babbabaababaaabbbaabaabb
+bbababbbaaabbaabbabbabaaaabaabaa
+abaababbbaabbababaaababbbabaababbaaaaabaabbabbbb
+ababababaaababaabbaaaabb
+bbbaaaaaababbaababaabbba
+babbbaababbbabbabbabaababaababbabbaababa
+baabaabbbbaaaaaabbbaaabb
+abbbaababbbbbabababbaabaaaaaabaaabbaaaaaabbbbaabaabbbbaaaabbbbabaababaab
+ababaabbaabababbbbabbaabaaababaabaaaaababaaaabba
+ababbbbbaabbaababababaababaaaaaaabbaaaaabbabbbaa
+abbaaabbabaaaabbbbbabbbbbabbaabbbbbaaaaaabbbabbbbbbaabba
+aaababbaaaaabaabbbaaababaaaabbbb
+aabaaababbbbbbabaaabbabaabbaaaaabbbbbbbbababababbbaababbbabbabab
+bbbaababbaaabbaabbbbbbaaabaaaaabaabbaababbaaaaab
+aaaabbbaababbaabbabaabbababaaabbbaabbaab
+bbbabababbababababbaabaa
+bbbbabaabbaababbaaaabbbaabbbbbab
+aaabbaaaaaaabbbaabbbbbbaabaaaabababbbaaabbaababbbaaaaaaaababbbbabababaaa
+aaaaabbababbababbbababbbbaaababbabaabbaaaababbaabbaabbaa
+bbabbabaaaaaabaabababbbbaaabbbba
+ababbbaabbababbaaaaaaaab
+babaaabbbaabbabaaaabaabb
+babbababbbbbabaabababaab
+bababbabbbaabaabbbbabaab
+abbbaabaaabbbbbbaabbbbbbaabaaabbbbbbbaaaababbaaaaababaaabaaabaaa
+abaabaaaabaababababaaabaaaabbbaabbabaaab
+ababbbabaaaaaaaababbbbab
+bbabbbbaabbbbabaaaaaabbbbababbaaabbbbbbbbbaabbbabbaaababababbbbbabbaabbabbabaaaabbbabbba
+abaaaabbaaabbaabaaabaaaabbbabbbbababbbaabaabbbab
+aabbbbbbbabbaababaabbababaabbbba
+baaaabbbbababbabbbaabbba
+abbbaaaaababbbababbabaaa
+bbbabbbaaaababbaabaabbaaabaababaabbabababbaaabbaaaaaaabbabaabbabbbbaabbb
--- a/input/day19_example.txt
+++ b/input/day19_example.txt
@@ -0,0 +1,12 @@
+0: 4 1 5
+1: 2 3 | 3 2
+2: 4 4 | 5 5
+3: 4 5 | 5 4
+4: "a"
+5: "b"
+
+ababbb
+bababa
+abbbab
+aaabbb
+aaaabbb
--- a/input/day20.txt
+++ b/input/day20.txt
--- a/input/day20_example.txt
+++ b/input/day20_example.txt
@@ -0,0 +1,107 @@
+Tile 2311:
+..##.#..#.
+##..#.....
+#...##..#.
+####.#...#
+##.##.###.
+##...#.###
+.#.#.#..##
+..#....#..
+###...#.#.
+..###..###
+
+Tile 1951:
+#.##...##.
+#.####...#
+.....#..##
+#...######
+.##.#....#
+.###.#####
+###.##.##.
+.###....#.
+..#.#..#.#
+#...##.#..
+
+Tile 1171:
+####...##.
+#..##.#..#
+##.#..#.#.
+.###.####.
+..###.####
+.##....##.
+.#...####.
+#.##.####.
+####..#...
+.....##...
+
+Tile 1427:
+###.##.#..
+.#..#.##..
+.#.##.#..#
+#.#.#.##.#
+....#...##
+...##..##.
+...#.#####
+.#.####.#.
+..#..###.#
+..##.#..#.
+
+Tile 1489:
+##.#.#....
+..##...#..
+.##..##...
+..#...#...
+#####...#.
+#..#.#.#.#
+...#.#.#..
+##.#...##.
+..##.##.##
+###.##.#..
+
+Tile 2473:
+#....####.
+#..#.##...
+#.##..#...
+######.#.#
+.#...#.#.#
+.#########
+.###.#..#.
+########.#
+##...##.#.
+..###.#.#.
+
+Tile 2971:
+..#.#....#
+#...###...
+#.#.###...
+##.##..#..
+.#####..##
+.#..####.#
+#..#.#..#.
+..####.###
+..#.#.###.
+...#.#.#.#
+
+Tile 2729:
+...#.#.#.#
+####.#....
+..#.#.....
+....#..#.#
+.##..##.#.
+.#.####...
+####.#.#..
+##.####...
+##..#.##..
+#.##...##.
+
+Tile 3079:
+#.#.#####.
+.#..######
+..#.......
+######....
+####.#..#.
+.#...#.##.
+#.#####.##
+..#.###...
+..#.......
+..#.###...
--- a/input/day21.txt
+++ b/input/day21.txt
@@ -0,0 +1,35 @@
+jfvltdz txzv szzbr fcbsv klzdr xclff jqqbnzz flzmlbf crfxz jxrlzm xcfpc tvk kdbx zlhlq gfpnx ccvsl zfl skllln lxqbsc frgnkt mrnd smjhxg cmqjlb jxdbh tsbffm mtjlb czbhh gbbxhp snsnj lmvx pbztj glvv jkzxn nnfps hnvrfvm fddx nhhgb hdt jg hrnzq tmgfr vjcbtd nklc fmbqgs hcg gpgrb qrgvj znqbr pfdkkzp vmrf mbqpfm pccmj bph hmngm fcbvh vtqhqs zsjlp rdbdd gtjmd bskstb krxj rglbcpq svqz jczm frssvh nmxdsnc hjbs xkpm tsvfrt txr flmm tjrm jccqsxs bncfz vlpq ngl dvfqqz hqxdv xzrdx qdnh hbqhvk spbxz pnxzqgp kjcdgh ttmcq dlvdt (contains peanuts)
+bjqt frgnkt ctbmdg hbqhvk skllln spbxz frssvh rdbdd gpgrb nndr dvfqqz jlnrn tsvfrt jccqsxs jkzxn znqbr vlpq hcg gtjmd lmvx zck jnd vghkr fmfnh rlsqd vjcbtd kbszttf mdsg pfdkkzp stnb tjlz bqc gfpnx mfvxhv pdss tzglth mtpfk cnhbh thprs kvcc hnvrfvm klzdr xcfpc kdxvzqm (contains peanuts)
+pngs tjlz nmxdsnc qdnh pccmj mkz rdbdd mbqpfm ngl znqbr tzglth tlbj klzdr pgrc fddx mxmvt srxrn gtjmd vdgsz dxzzp zfsmv svcmg mzjvq txr jkzxn smjhxg dptl flmm xlcgr srpqk kdbx bctn hnvrfvm qkvrf kvcc qzqdq krdmn vlpq tmjltg kdxvzqm hdt thprs pfdkkzp nklc cmqjlb jrrgck gpgrb mdnchc gzngn qrgvj pznt pdss zjh crfxz krxj xcfpc svrvv ctbmdg spbxz (contains shellfish)
+xcfpc zfl cnhbh mdx tjlz pnxzqgp drzm glljh xsndjl hrnzq pdss zck kjcdgh pgrc bph gtjmd xmcsr ctgnz kbszttf gpgrb spbxz vtqhqs snsnj brjd znqbr mbqpfm crfxz blbfl rjds gdsk kdxvzqm mdnnfp mrnd mzjvq flzmlbf pznt pggzp txr vxx bncfz lzfmghs krxj pfdkkzp rtjxbbd (contains dairy, shellfish, fish)
+mdx glcfml jqkxx jccqsxs kvcc nndr kbszttf mfvxhv rjds tjrm spbxz gtjmd vtqhqs fmbqgs dxzzp snptbf hrnzq rtjxbbd tmgfr sckhr hsdnz xkpm txzv fgrmrqhp gxbs gfpnx mdnnfp kbtkrcf drzm tbptvzf dtqplpj vxx cmtq zsjlp gpgrb glvv qrgvj tmjltg hnvrfvm pbztj czbhh tvk cnhbh krdmn flzmlbf lblbm mrnd znqbr kdbx xcfpc nhhgb mdsg zck txr stnb hdt hjbs pfdkkzp skks klh zfl (contains dairy)
+skllln tvk srxrn snptbf cnhbh gbbxhp jczm spbxz pznt kbtkrcf fmbqgs tjlz frssvh pmhxl znqbr mtpfk fcbvh rdbdd xpmmdc vjcbtd cmqjlb jqqbnzz nnfps lblbm kdxvzqm qzqdq bjqt txzv qrgvj tmjltg mxfrnq hbqhvk gtjmd jlnrn kvcc hsdnz dfllfp mfvxhv mfcrq tgclx xlcgr glvv czbhh tsbffm hmnt xcfpc mkz cmtq gpgrb (contains soy)
+gtjmd zbj vdgsz stnb tsbffm tjlz pdss jqqbnzz nklc srxrn klh glljh ctbmdg dptl jczm pfdkkzp jfvltdz nhhgb glvv jccqsxs hsdnz bskstb brjd ctgnz rjds tjrm qrgvj zck spbxz zfl xbp mfcrq svrvv zsjlp bqc pbztj xsndjl bctn lblbm fmfnh kdxvzqm cdntx hjbs gnkr rtjxbbd hdt hcg vjcbtd hmnt skqbbj frgnkt znqbr klzdr tmjltg nndr hsdqb tgclx txzv hnnz mdx pngs jg snptbf czbhh cnhbh jrrgck jlnrn gpgrb mfvxhv mdnnfp sckhr pccmj gfpnx dxzzp tbptvzf (contains peanuts, soy, dairy)
+nkshjm pgmqs znqbr cdntx hsdnz kdxvzqm pmhxl tjlz nndr lzczv mtjlb jqkxx bjrbknjm pbztj nmpp mkz tbptvzf krxj bctn ctgnz qlzxbc hbqhvk mbqpfm dvfqqz gtjmd mfvxhv gdsk snptbf cmqjlb gpgrb jfvltdz vlpq zjh pggzp xkpm xpmmdc tgclx bqc spbxz kjcdgh lflzqr glvv stnb tjrm txzv qzqdq hjbs ccvsl jxdbh xcfpc bncfz flmm blbfl zbj rglbcpq srpqk tsvfrt fcbsv rtjxbbd bph tsbffm smjhxg tmjltg (contains shellfish)
+snsnj tmjltg lxqbsc czbhh txzv svqz krdmn tjlz jg bnrf nmxdsnc ndhx zck zjh skks rdbdd bnnt srpqk svrvv spbxz pdss cmqjlb vmrf crfxz gpgrb jdvtlsv sgh mkz pznt tgclx kdxvzqm jfvltdz ccvsl jlnrn gdsk pfdkkzp flzmlbf xcfpc jqkxx dptl hrnzq vghkr tmgfr glvv mfvxhv gtjmd fgrmrqhp mdnnfp klh glljh kdbx lzczv klzdr (contains nuts, fish)
+znqbr tsvfrt bjrbknjm kbtkrcf hsxp xsndjl jqkxx mrnd tjlz klzdr krxj gnzr nhhgb hqxdv mggk hsdqb zfl svqz hmngm ctbmdg tbptvzf bctn mdx gfpnx bskstb blbfl thprs sckhr lzfmghs rdbdd gbbxhp rglbcpq lmvx jkzxn lblbm bncfz ctgnz tjrm tlbj sndrzm tsbffm hdt spbxz jfvltdz gpgrb hrkf txzv ccvsl mtpfk vlpq pgmqs ttmcq pfdkkzp ndhx mdsg skllln xcfpc bph bdj (contains nuts, shellfish)
+vdgsz srpqk jccqsxs txzv gtjmd xzrdx jdvtlsv hcg hjbs tsbffm vlpq bctn fmbqgs krdmn crfxz gpgrb zjh skllln bjqt kdxvzqm mdnchc zfl svrvv zlhlq tzglth ccvsl frgnkt xpmmdc rtjxbbd dptl dlvdt kdbx xclff gbbxhp lxqbsc vmrf lmvx smjhxg skqbbj nndr jnd rlsqd xmcsr pfdkkzp hmnt jfvltdz gnzr znqbr ctbmdg svcmg flzmlbf tjlz tbptvzf bncfz vxx tmjltg xcfpc qlzxbc klh jg xbp mrnd pgrc qkvrf qdnh qzqdq vghkr zfsmv fddx dkzz fcbsv mggk (contains shellfish, soy, eggs)
+krxj kbszttf hnvrfvm mkz fjsgm nkshjm tjlz mfvxhv pccmj gnzr txzv flmm czbhh bnrf jccqsxs cnhbh gtjmd klh jg skllln hdt jrrgck nndr vtqhqs hrnzq dtqplpj blbfl glljh snptbf fddx spbxz pnxzqgp bjqt gnkr svqz dptl bncfz lhqxr pfdkkzp zsjlp srpqk dlvdt xcfpc dvfqqz zfl lmvx mzjvq thprs pngs sgh tmjltg tbptvzf vxx nmpp jdvtlsv hrkf rlsqd xzrdx mrnd skqbbj xclff szzbr srxrn vlpq nmxdsnc qkvrf hcg mfcrq fcbvh kbtkrcf mxmvt hjbs jfvltdz gpgrb (contains soy, shellfish)
+bnrf jrrgck xcfpc kdxvzqm lmvx xzrdx pfdkkzp crfxz gtjmd krxj qkvrf kdbx jdvtlsv mdnchc mbqpfm jfvltdz txzv vghkr jqkxx jxrlzm klzdr bnnt xpmmdc tsvfrt fcbvh xbp tlbj rglbcpq hdt vdgsz spbxz dxzzp hsdnz jg fgrmrqhp tmjltg jxdbh gjt mggk svrvv zbj mxmvt bncfz hsdqb qdnh hbqhvk kbszttf jkzxn dvfqqz tsbffm mrnd jnd hsxp zck tjlz gpgrb (contains nuts, soy, dairy)
+lmvx qzqdq mtpfk dkzz zck frssvh pbztj qlzxbc pccmj sckhr zfl dptl fddx mrnd gdsk mdnnfp hnvrfvm jfvltdz mtjlb lblbm spbxz hsdqb zbj krdmn lzfmghs pfdkkzp gzngn flmm hrnzq jqkxx znqbr jrrgck jkzxn svcs xcfpc mdsg fjsgm frgnkt rdbdd klh cmqjlb hrkf mxmvt hdt tzglth glcfml hbqhvk mkz bncfz pdss gtjmd jczm nrdv tjrm svrvv flzmlbf txzv pmhxl tjlz dvfqqz (contains peanuts, soy, nuts)
+mfvxhv pfdkkzp nrdv xcfpc znqbr zck gjt snsnj lmvx nhhgb fgrmrqhp bdj bnrf hrnzq lhqxr kdbx spbxz zfl glvv gpgrb vmrf hnvrfvm pccmj bqc fjsgm jnd xpmmdc hmnt bjqt mrnd jczm fcbvh tjlz hjbs frssvh gnkr pgmqs lxqbsc skqbbj hrkf frgnkt tbptvzf rglbcpq xbp sckhr txzv vjcbtd jqqbnzz mkz (contains peanuts)
+jczm gpgrb dfllfp tzglth txzv fmfnh jccqsxs zfl spbxz nhhgb cdntx txr kdxvzqm smjhxg fgrmrqhp qkvrf skqbbj kbszttf rjds snptbf cmqjlb szzbr glvv sckhr mbqpfm mxmvt gnzr pmhxl jqqbnzz bnrf frssvh bncfz znqbr dvfqqz mxfrnq hcg ttmcq kbtkrcf czbhh mdnchc hnnz xcfpc gbbxhp stnb pfdkkzp nrdv gtjmd zsjlp qzqdq flzmlbf vdgsz krdmn bjqt zjh kjcdgh sgh lblbm pdss hsdnz vxx skks mggk ctgnz xzrdx jqkxx klzdr fddx lflzqr svcmg xmcsr (contains nuts, shellfish)
+hsxp tjlz crfxz xcfpc pggzp spbxz skqbbj jkzxn tzglth svrvv mtjlb gtjmd hmnt jccqsxs vlpq tmjltg zfl gpgrb lxqbsc znqbr pfdkkzp mdnchc dlvdt gbbxhp hdt sgh rjds skks mkz hmngm vxx mzjvq cnhbh pgmqs lzfmghs qkvrf tsvfrt czbhh qrgvj hrnzq lflzqr dvfqqz xclff jxdbh pdss fcbvh (contains wheat, shellfish, eggs)
+jccqsxs rglbcpq pmhxl znqbr vdgsz jqkxx pngs txzv mdsg tvk cmtq dfllfp lhqxr fddx skllln dvfqqz crfxz lzczv brjd tlbj gfpnx gtjmd gxbs gnkr xmcsr dlvdt hsdnz bdj nklc zjh lzfmghs jqqbnzz pznt lflzqr bnrf cdntx tmjltg xcfpc lxqbsc tjlz mfcrq rlsqd kdbx vjcbtd dxzzp spbxz mkz pccmj hbqhvk nndr pfdkkzp fcbsv klzdr hdt svqz svrvv pbztj (contains shellfish)
+skks tzglth lmvx bph txr gpgrb klzdr txzv jnd svcmg xclff zsjlp jrrgck spbxz kjcdgh mdnchc kbtkrcf bqc bctn kbszttf dxzzp gtjmd mtjlb pfdkkzp hnvrfvm smjhxg gnkr pggzp vjcbtd lzfmghs vtqhqs tjlz fgrmrqhp svrvv fcbvh ttmcq skllln fjsgm xpmmdc xcfpc nkshjm crfxz lzczv zfl rtjxbbd hsxp cmtq snptbf skqbbj cdntx (contains nuts, peanuts, soy)
+xcfpc hrkf txr gxbs snptbf kbtkrcf jxrlzm mggk nmpp txzv vghkr mfcrq sckhr nrdv lflzqr xlcgr pfdkkzp hmnt fcbvh mkz glcfml znqbr cmtq spbxz crfxz gtjmd mdsg xzrdx skks stnb nkshjm zsjlp dptl fmbqgs kjcdgh jfvltdz blbfl vtqhqs lzfmghs hjbs hdt lxqbsc klzdr tjlz vxx pngs lmvx zck gdsk hsxp pccmj jrrgck fmfnh jqkxx fjsgm ccvsl jczm tlbj qkvrf smjhxg gjt jqqbnzz svqz rjds vlpq pmhxl qlzxbc pggzp lhqxr (contains wheat)
+bdj bph smjhxg pggzp svrvv dvfqqz pnxzqgp rglbcpq skks dlvdt pccmj tjlz hsdqb zbj qkvrf pmhxl fmfnh cmtq txzv ctbmdg vghkr cmqjlb gtjmd vjcbtd xpmmdc gzngn hrkf blbfl srxrn ctgnz rlsqd dxzzp fcbsv vxx zfsmv lblbm lmvx pgmqs tzglth bncfz mdx vtqhqs drzm jg jnd pfdkkzp xcfpc zfl zjh jfvltdz skllln spbxz znqbr mtpfk dfllfp mxmvt zck svcmg kbtkrcf xsndjl gjt kdbx klh nnfps (contains peanuts, wheat)
+jrrgck jfvltdz bjqt nndr znqbr xclff lzfmghs lxqbsc xbp dlvdt txzv tjrm ttmcq gtjmd rdbdd skqbbj dtqplpj kdbx mfcrq pggzp nhhgb tgclx pznt gnkr vghkr xcfpc klzdr krxj lzczv klh czbhh vtqhqs skllln rjds gbbxhp hsdnz bnnt qkvrf glvv bnrf tsbffm lblbm zlhlq dvfqqz bph jkzxn dkzz cnhbh tmgfr hsxp crfxz lhqxr ndhx ngl glcfml pfdkkzp mbqpfm ctgnz bdj spbxz brjd fcbvh gpgrb nklc smjhxg (contains dairy, peanuts, fish)
+ttmcq gbbxhp vxx cmtq fmbqgs nklc svqz znqbr hsxp hnvrfvm mtpfk pccmj pdss jczm mrnd zbj gtjmd klzdr thprs czbhh fddx blbfl tlbj fmfnh jdvtlsv txr rdbdd xcfpc glljh snsnj tjlz jqkxx tgclx gpgrb gnzr skllln nrdv qkvrf sgh kbtkrcf hdt pfdkkzp kdxvzqm bnnt jnd jg hqxdv spbxz flmm szzbr sckhr (contains nuts, dairy)
+svqz txzv gpgrb fcbvh gnzr tjlz drzm vmrf qkvrf dlvdt hsdqb hmnt spbxz tjrm mggk hnnz sckhr bjrbknjm jfvltdz xcfpc gtjmd zjh tvk srxrn mfcrq vjcbtd fcbsv xkpm gjt hbqhvk krdmn mdnchc zlhlq ndhx pfdkkzp mdnnfp xzrdx jxdbh gnkr zck pznt bncfz nmxdsnc hrnzq skqbbj mdx kdxvzqm snptbf hsdnz mdsg dxzzp rdbdd (contains shellfish, eggs, peanuts)
+dptl rlsqd tjlz mdsg pfdkkzp tzglth mxfrnq gzngn tmjltg mggk hmngm mdnchc nkshjm hnnz zlhlq cmtq vxx hnvrfvm sgh frssvh pdss mdnnfp xcfpc kbtkrcf qzqdq mrnd xbp nndr znqbr szzbr ctgnz spbxz ndhx svqz pbztj bdj smjhxg kbszttf gpgrb jkzxn hqxdv dtqplpj kdxvzqm crfxz cdntx mbqpfm hsxp dxzzp nnfps pgrc cnhbh fmbqgs pnxzqgp svrvv mdx klzdr zjh tsbffm srxrn glcfml rglbcpq hcg gtjmd glljh zck pngs jczm lxqbsc pccmj glvv (contains dairy, peanuts)
+znqbr hnvrfvm svrvv kbszttf bctn jccqsxs drzm rlsqd jlnrn srxrn rjds gjt skqbbj qrgvj kjcdgh vghkr svcmg gxbs xcfpc rtjxbbd zfl ndhx lzfmghs qdnh xkpm snsnj bqc lblbm dptl fcbvh gtjmd ccvsl txzv jfvltdz kdxvzqm mtpfk bph tjrm xpmmdc jqqbnzz cnhbh czbhh dtqplpj fgrmrqhp nmxdsnc gpgrb pggzp glcfml hrkf ttmcq mfcrq jczm zlhlq cmtq mdx txr vjcbtd mggk qzqdq skks svcs sndrzm bjqt hsxp tmgfr dkzz jg zck tjlz spbxz pnxzqgp klzdr mdsg zfsmv xbp (contains fish, wheat)
+vjcbtd jdvtlsv ccvsl krxj qlzxbc fmfnh zjh hcg jxrlzm spbxz txzv sgh flzmlbf hsdqb nhhgb srpqk xlcgr pggzp skqbbj dlvdt mdsg gzngn pmhxl jfvltdz dptl fgrmrqhp bjqt hsxp tvk gnzr xcfpc qkvrf gtjmd glljh bdj tmgfr jg pgrc hrnzq nnfps jlnrn svcmg zbj klzdr pccmj jqqbnzz gpgrb tmjltg mrnd hnvrfvm znqbr mbqpfm qzqdq snsnj kbtkrcf smjhxg qdnh hrkf mfvxhv srxrn tgclx tjlz fjsgm sndrzm jccqsxs xsndjl (contains eggs)
+ngl hjbs tsvfrt brjd zfl lflzqr jrrgck pbztj jxdbh srxrn mfvxhv thprs nkshjm tmgfr jqqbnzz rglbcpq drzm cdntx pggzp kdxvzqm mtpfk gpgrb klzdr vjcbtd mkz jnd kvcc znqbr qzqdq tgclx pdss bskstb skqbbj xkpm spbxz hsxp sgh bdj ccvsl gdsk svcs bqc lblbm gnkr gxbs tvk xpmmdc klh czbhh pccmj jxrlzm pnxzqgp pfdkkzp xzrdx fmfnh tjlz zlhlq mdnchc bctn dptl xcfpc snptbf rtjxbbd txzv bjqt mggk jqkxx flmm nklc cmtq (contains dairy)
+jxrlzm pnxzqgp rdbdd frgnkt znqbr gpgrb lblbm srxrn jfvltdz mrnd jkzxn kjcdgh skks bjrbknjm nmxdsnc zjh tjrm xlcgr kdxvzqm fmfnh jnd spbxz nndr zfl dvfqqz xcfpc tmgfr mfvxhv bdj nhhgb hsxp glljh dlvdt txzv vtqhqs zck nnfps gtjmd jrrgck jczm jlnrn drzm cmqjlb fddx xpmmdc hsdnz hqxdv qdnh vjcbtd dptl svcmg bnrf xbp qkvrf kbszttf pznt mfcrq stnb mzjvq pgrc xkpm fcbvh vdgsz mxmvt hjbs hnnz pmhxl tlbj hnvrfvm bncfz zfsmv xsndjl xmcsr bjqt vmrf tjlz bskstb mdx jxdbh gzngn ndhx vlpq (contains fish, wheat, nuts)
+ttmcq txr pmhxl frgnkt xbp gxbs zlhlq szzbr crfxz fmfnh smjhxg hmngm xclff glvv tmgfr thprs glcfml fjsgm tsvfrt znqbr spbxz svrvv nrdv lzfmghs tgclx jczm fgrmrqhp bctn mtpfk cdntx gtjmd fcbsv mkz rglbcpq mbqpfm rjds bph jfvltdz ngl zfl rdbdd tjlz gjt nmxdsnc hsdqb qrgvj gfpnx txzv hdt pfdkkzp tvk sckhr snptbf flmm vtqhqs lhqxr fcbvh hnnz mfvxhv nmpp bjrbknjm nkshjm fmbqgs svcs jqkxx gpgrb mtjlb zfsmv dlvdt pngs svqz hbqhvk hmnt ccvsl (contains peanuts, dairy, wheat)
+nmxdsnc txzv pggzp pznt cmqjlb hsdnz snsnj ndhx dlvdt ttmcq zbj xmcsr zlhlq flzmlbf tmjltg mdnchc qdnh pngs pmhxl cmtq skqbbj bph czbhh fmbqgs spbxz xclff drzm gdsk znqbr dfllfp tjlz zjh fcbvh pfdkkzp rjds glvv mkz nndr hbqhvk krdmn xcfpc skks mtpfk gtjmd rlsqd hrnzq svcs fcbsv lmvx ctbmdg frgnkt zfsmv sckhr (contains nuts, wheat, eggs)
+nrdv zlhlq mzjvq nnfps tmgfr fcbvh jccqsxs xcfpc cnhbh gpgrb brjd hnvrfvm tjlz xzrdx vmrf lmvx skllln zsjlp snsnj szzbr lxqbsc dvfqqz pdss spbxz zfsmv mggk gtjmd tgclx cmqjlb zck rjds hjbs gdsk mfvxhv thprs fcbsv lblbm srxrn jqkxx flmm jnd qdnh lzczv fjsgm xlcgr snptbf znqbr txzv stnb czbhh gnzr (contains wheat)
+vlpq svcs hqxdv mxfrnq zfl frssvh mggk kdbx ctbmdg tbptvzf zck xzrdx krdmn klh fcbsv znqbr sgh frgnkt lzfmghs cmtq xcfpc txzv rtjxbbd rjds fcbvh xclff pfdkkzp jccqsxs dvfqqz gtjmd hrkf hsdqb gnzr jqkxx lmvx flmm xlcgr mdsg tjlz jlnrn hnvrfvm hcg bdj lzczv gzngn fmbqgs spbxz bskstb jg nklc hdt gjt jrrgck skks srpqk ngl vxx (contains eggs, wheat)
+znqbr rdbdd jfvltdz gnzr mdx glcfml vtqhqs lblbm frssvh hsdnz jxdbh xsndjl pccmj kdxvzqm fgrmrqhp krdmn hnnz mtpfk gtjmd jccqsxs nklc vlpq svcs brjd xcfpc srxrn cdntx smjhxg pggzp fmfnh pdss nmxdsnc kbszttf xzrdx bnnt tvk fcbsv zfl mbqpfm xlcgr nnfps spbxz kdbx dlvdt gnkr tlbj vmrf hbqhvk mrnd dvfqqz tjlz gpgrb cnhbh hnvrfvm qrgvj snptbf tmjltg txzv mdnnfp nrdv jg xclff crfxz mdsg tsvfrt hdt dptl lflzqr hsdqb (contains shellfish)
+tjlz srxrn gpgrb blbfl dvfqqz nrdv fmfnh smjhxg jlnrn tvk hbqhvk bdj hsdqb klh qrgvj jczm spbxz jnd lxqbsc rglbcpq jxdbh fgrmrqhp zbj znqbr pfdkkzp pngs dkzz mbqpfm hmngm vjcbtd mrnd jfvltdz jccqsxs xmcsr mfvxhv bqc mdsg pgmqs stnb svcs xcfpc kvcc skqbbj zlhlq svcmg gtjmd glcfml dtqplpj bjrbknjm gdsk nnfps qdnh hrkf ngl mdnchc bncfz gnzr srpqk sgh gjt fcbsv hnvrfvm hmnt (contains nuts, dairy, peanuts)
--- a/input/day21_example.txt
+++ b/input/day21_example.txt
@@ -0,0 +1,4 @@
+mxmxvkd kfcds sqjhc nhms (contains dairy, fish)
+trh fvjkl sbzzf mxmxvkd (contains dairy)
+sqjhc fvjkl (contains soy)
+sqjhc mxmxvkd sbzzf (contains fish)
--- a/input/day22.txt
+++ b/input/day22.txt
@@ -0,0 +1,53 @@
+Player 1:
+28
+13
+25
+16
+38
+3
+14
+6
+29
+2
+47
+20
+35
+43
+30
+39
+21
+42
+50
+48
+23
+11
+34
+24
+41
+
+Player 2:
+27
+37
+9
+10
+17
+31
+19
+33
+40
+12
+32
+1
+18
+36
+49
+46
+26
+4
+45
+8
+15
+5
+44
+22
+7
--- a/input/day22_example.txt
+++ b/input/day22_example.txt
@@ -0,0 +1,13 @@
+Player 1:
+9
+2
+6
+3
+1
+
+Player 2:
+5
+8
+4
+7
+10
--- a/input/day23.txt
+++ b/input/day23.txt
@@ -0,0 +1 @@
+186524973
--- a/input/day23_example.txt
+++ b/input/day23_example.txt
@@ -0,0 +1 @@
+389125467
--- a/src/day11.rs
+++ b/src/day11.rs
@@ -6,7 +6,7 @@ use crate::day11::GridState::EmptySeat;
 pub fn solve() {
    let lines = util::read_file("input/day11.txt");

-    let seats = Seats::parse(&lines);
+    let seats = Seats::parse(&lines, 1);

    let part1 = solve_part1(&seats);

@@ -25,8 +25,8 @@ fn solve_part1(seats: &Seats) -> usize {

    loop {
        let mut changes = false;
-        for y in 0..seats.height {
-            for x in 0..seats.width {
+        for y in 1..seats.height-1 {
+            for x in 1..seats.width-1 {
                let seat = last_seats.get(&x, &y);
                if seat != &Floor {
                    let occupied = last_seats.count_occupied_neighbors(&x, &y);
@@ -66,8 +66,8 @@ fn solve_part2(seats: &Seats, visible_chairs: &Vec<Option<Vec<(usize, usize)>>>)
                        changes = true;
                        next_seats.set(&x, &y, FilledSeat);
                    } else if seat == &FilledSeat && occupied >= 5 {
-                        next_seats.set(&x, &y, EmptySeat);
                        changes = true;
+                        next_seats.set(&x, &y, EmptySeat);
                    }
                }
            }
@@ -94,16 +94,16 @@ impl Seats {

    const DIRECTIONS: [(i32, i32); 8] = [(-1, 1), (-1, 0), (-1, -1), (0, -1), (0, 1), (1, 1), (1, 0), (1, -1)];

-    fn parse(lines: &Vec<String>) -> Seats {
+    fn parse(lines: &Vec<String>, padding: usize) -> Seats {

-        let height = lines.len();
-        let width = lines[0].len();
+        let height = lines.len() + padding * 2;
+        let width = lines[0].len() + padding * 2;
        let mut grid = vec!(GridState::Floor; width * height);
        for y in 0..lines.len() {
            let line = &lines[y];
            let mut line_chars = line.chars();
            for x in 0..lines[0].len() {
-                grid[x + y * width] = GridState::parse(&line_chars.next().unwrap())
+                grid[(x + padding) + (y + padding) * width] = GridState::parse(&line_chars.next().unwrap())
            }
        }

@@ -170,20 +170,15 @@ impl Seats {

    fn count_occupied_neighbors(&self, x: &usize, y: &usize) -> u8 {

-        let x_upper = x == &(self.width - &ONE);
-        let x_lower = x == &0;
-        let y_upper = y == &(self.height - &ONE);
-        let y_lower = y == &0;
-
        return
-            if !x_lower && !y_lower && self.is_occupied(&(x - &ONE), &(y - &ONE)) { 1 } else { 0 } +
-            if !x_lower && self.is_occupied(&(x - &ONE), &y) { 1 } else { 0 } +
-            if !x_lower && !y_upper && self.is_occupied(&(x - &ONE), &(y + ONE)) { 1 } else { 0 } +
-            if !y_lower && self.is_occupied(&x, &(y - ONE)) { 1 } else { 0 } +
-            if !y_upper && self.is_occupied(&x, &(y + ONE)) { 1 } else { 0 } +
-            if !x_upper && !y_lower && self.is_occupied(&(x + ONE), &(y - ONE)) { 1 } else { 0 } +
-            if !x_upper && self.is_occupied(&(x + ONE), &y) { 1 } else { 0 } +
-            if !x_upper && !y_upper && self.is_occupied(&(x + ONE), &(y + ONE)) { 1 } else { 0 }
+            if self.is_occupied(&(x - &ONE), &(y - &ONE)) { 1 } else { 0 } +
+            if self.is_occupied(&(x - &ONE), &y) { 1 } else { 0 } +
+            if self.is_occupied(&(x - &ONE), &(y + ONE)) { 1 } else { 0 } +
+            if self.is_occupied(&x, &(y - ONE)) { 1 } else { 0 } +
+            if self.is_occupied(&x, &(y + ONE)) { 1 } else { 0 } +
+            if self.is_occupied(&(x + ONE), &(y - ONE)) { 1 } else { 0 } +
+            if self.is_occupied(&(x + ONE), &y) { 1 } else { 0 } +
+            if self.is_occupied(&(x + ONE), &(y + ONE)) { 1 } else { 0 }

    }

--- a/src/day12.rs
+++ b/src/day12.rs
@@ -0,0 +1,174 @@
+use super::util;
+use crate::day12::Heading::{North, East, South, West};
+use std::mem::swap;
+
+pub fn solve()
+{
+    let lines = util::read_file("input/day12.txt");
+    let instructions = lines.iter().map(|s| Instruction::parse(s)).collect::<Vec<_>>();
+
+    let ship_state = execute(&instructions);
+    let part1 = ship_state.manhattan_distance();
+    println!("Day 12 Part 1: {}", part1);
+
+    let ship_state2 = execute_with_waypoint(&instructions);
+    let part2 = ship_state2.manhattan_distance();
+    println!("Day 12 Part 2: {}", part2);
+}
+
+fn execute(instructions: &Vec<Instruction>) -> ShipState {
+
+    let mut res = ShipState { position_n: 0, position_e: 0, heading: East };
+
+    for instruction in instructions {
+        res.apply(&instruction);
+    }
+
+    return res;
+}
+
+fn execute_with_waypoint(instructions: &Vec<Instruction>) -> ShipState {
+
+    let mut ship = ShipState { position_n: 0, position_e: 0, heading: East };
+    let mut waypoint = WaypointState { position_n: 1, position_e: 10 };
+
+    for instruction in instructions {
+        // println!("Instruction: {}{}", instruction.action, instruction.amount);
+
+        if instruction.action == 'F' {
+            ship.position_n += waypoint.position_n * instruction.amount as i32;
+            ship.position_e += waypoint.position_e * instruction.amount as i32;
+        } else {
+            waypoint.apply(instruction);
+        }
+        // println!("Ship: {:?}, Waypoint: {:?}", ship, waypoint);
+    }
+
+    return ship;
+
+}
+
+#[derive(Debug)]
+struct ShipState {
+    position_n: i32,
+    position_e: i32,
+    heading: Heading,
+}
+
+impl ShipState {
+    fn manhattan_distance(&self) -> i32 {
+        return self.position_n.abs() + self.position_e.abs();
+    }
+
+    fn apply(&mut self, instruction: &Instruction) {
+
+        match instruction.action {
+            'N'=> self.position_n += instruction.amount as i32,
+            'S' => self.position_n -= instruction.amount as i32,
+            'E' => self.position_e += instruction.amount as i32,
+            'W' => self.position_e -= instruction.amount as i32,
+            'L' => self.turn_left(instruction.amount),
+            'R' => self.turn_left(360 - (instruction.amount % 360)),
+            'F' => self.move_forward(instruction.amount),
+            _ => panic!("Unknown instruction: {}", instruction.action)
+        }
+
+    }
+
+    fn move_forward(&mut self, amount: u32) {
+        match self.heading {
+            North => self.position_n += amount as i32,
+            East => self.position_e += amount as i32,
+            South => self.position_n -= amount as i32,
+            West => self.position_e -= amount as i32,
+        }
+    }
+
+    fn turn_left(&mut self, amount: u32) {
+
+        assert_eq!(amount % 90, 0, "Only rotations of (multiples of) 90 degrees are supported");
+
+        let count = amount / 90;
+        for _ in 0..count {
+            self.heading = self.heading.turn_left();
+        }
+    }
+}
+
+#[derive(Debug)]
+struct WaypointState {
+    position_n: i32,
+    position_e: i32,
+}
+
+impl WaypointState {
+
+    fn apply(&mut self, instruction: &Instruction) {
+
+        match instruction.action {
+            'N'=> self.position_n += instruction.amount as i32,
+            'S' => self.position_n -= instruction.amount as i32,
+            'E' => self.position_e += instruction.amount as i32,
+            'W' => self.position_e -= instruction.amount as i32,
+            'L' => self.rotate_left_around_origin(instruction.amount),
+            'R' => self.rotate_left_around_origin(360 - instruction.amount),
+            _ => panic!("Unknown instruction: {}", instruction.action)
+        }
+    }
+
+    fn rotate_left_around_origin(&mut self , amount: u32) {
+        assert_eq!(amount % 90, 0, "Only rotations of (multiples of) 90 degrees are supported");
+
+        if amount % 360 == 0 { return; }
+
+        match amount % 360 {
+            90 => {
+                swap(&mut self.position_n, &mut self.position_e);
+                self.position_e *= -1;
+            }
+            180 => {
+                self.position_n *= -1;
+                self.position_e *= -1;
+            }
+            270 => {
+                swap(&mut self.position_n, &mut self.position_e);
+                self.position_n *= -1;
+            }
+            _ => panic!("Unsupported amount of degrees")
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Instruction {
+    action: char,
+    amount: u32,
+}
+
+#[derive(Debug)]
+enum Heading {
+    North, East, South, West
+}
+
+impl Heading {
+
+    fn turn_left(&self) -> Heading {
+        return match self {
+            North => West,
+            West => South,
+            South => East,
+            East => North
+        };
+    }
+}
+
+impl Instruction {
+
+    fn parse(line: &String) -> Instruction {
+
+        return Instruction {
+            action: line.chars().next().unwrap(),
+            amount: line[1..].parse::<u32>().unwrap(),
+        }
+    }
+}
--- a/src/day13.rs
+++ b/src/day13.rs
@@ -0,0 +1,73 @@
+use super::util;
+
+pub fn solve() {
+    let lines = util::read_file("input/day13.txt");
+
+    let target_time = lines[0].parse::<u32>().unwrap();
+    let part1 = lines[1].split(",").filter(|s| s != &"x")
+        .map(|s| s.parse::<u32>().unwrap())
+        .map(|t| (t, t - (target_time % t)))
+        .min_by_key(|t| t.1)
+        .map(|bt| bt.0 * bt.1)
+        .unwrap();
+    println!("Day 13 Part 1: {}", part1);
+
+
+    let schedule_parts = lines[1].split(",").collect::<Vec<_>>();
+    let mut schedules = Vec::new();
+    // print!("[");
+    for i in 0..schedule_parts.len() {
+        let s = schedule_parts[i];
+        if s == "x" { continue; }
+        let bus_id = s.parse::<u64>().unwrap();
+        let mut offset = i as u64;
+        if offset > bus_id { offset = offset % bus_id; }
+        // print!("(x + {}) mod {} = 0, ", offset, bus_id );
+        schedules.push(Schedule {
+             bus_id, offset
+        });
+    }
+    // println!("]");
+
+    schedules.sort_by_key(|s| u64::max_value() - s.bus_id);
+    let part2 = find_fitting(&schedules);
+
+    println!("Day 13 Part 2: {}", part2);
+}
+
+fn find_fitting(schedules: &Vec<Schedule>) -> u64 {
+
+    let mut root_schedule = find_fitting_match(&schedules[0], &schedules[1]);
+    for schedule in schedules.iter().skip(2) {
+        root_schedule = find_fitting_match(schedule, &root_schedule)
+    }
+    return root_schedule.bus_id - root_schedule.offset;
+
+}
+
+
+fn find_fitting_match(s1: &Schedule, s2: &Schedule) -> Schedule {
+
+    // We know that the pattern repeats every s1.bus_id * s2.bus_id (and at no other times, since all bus_ids are at least co-prime).
+    // So all we need to do is find out what offset works:
+    let match_bus_id = s1.bus_id * s2.bus_id;
+    for mult in 0..s1.bus_id {
+        let offset = mult * s2.bus_id + s2.offset;
+        assert!(offset < match_bus_id, "Offset must not be bigger than the bus_id");
+        let solution = match_bus_id - offset;
+        if (solution + s1.offset) % s1.bus_id == 0 {
+            return Schedule {
+                bus_id: match_bus_id,
+                offset,
+            }
+        }
+    }
+    panic!("Couldn't find match!!!");
+
+}
+
+#[derive(Debug)]
+struct Schedule {
+    bus_id: u64,
+    offset: u64,
+}
--- a/src/day14.rs
+++ b/src/day14.rs
@@ -0,0 +1,161 @@
+use super::util;
+use std::collections::HashMap;
+
+pub fn solve() {
+
+    let lines = util::read_file("input/day14.txt");
+
+    let part1 = solve_part1(&lines);
+    println!("Day X Part 1: {}", part1);
+
+
+    let part2 = solve_part2(&lines);
+    println!("Day X Part 2: {}", part2);
+}
+
+fn solve_part1(lines: &Vec<String>) -> u64 {
+
+    let mut mem = vec!{0u64; 1 << 16};
+    let mut mask = BitMask { ones_mask: 0, zeros_mask: !0 };
+    for line in lines {
+
+        if line.starts_with("mask = ") {
+            mask = BitMask::parse(&String::from(&line[("mask = ".len())..]))
+        } else {
+            let instr = Instruction::parse(line);
+            mem[instr.pos] = mask.apply(instr.n);
+        }
+    }
+    return mem.iter().sum();
+}
+
+fn solve_part2(lines: &Vec<String>) -> u64 {
+
+    /*
+    Idea for performance optimalization: use a Vec containing the "root" memory position, and
+    the mask of the floats used to write to that position.
+    Whenever something is written, check (using bit operations) if a collision between existing
+    memory positions is possible. If that is the case, modify the old (existing) entry by
+     removing all overlapping entries in the float mask.
+     */
+
+    let mut mem: HashMap<u64, u64> = HashMap::new();
+    let mut mask = MemoryBitMask { ones_mask: 0, float_masks: Vec::new() };
+    for line in lines {
+
+        if line.starts_with("mask = ") {
+            mask = MemoryBitMask::parse(&String::from(&line[("mask = ".len())..]))
+        } else {
+            let instr = Instruction::parse(line);
+            mask.set_all(instr.pos as u64, instr.n, &mut mem);
+        }
+    }
+    return mem.values().sum();
+}
+
+struct BitMask {
+    /// One (1) everywhere except where the mask should be zero (0)
+    zeros_mask: u64,
+    /// Zero everywhere except where the mask is 1
+    ones_mask: u64,
+}
+
+impl BitMask {
+
+    fn parse(input: &String) -> BitMask {
+
+        let mut zeros = u64::max_value();
+        let mut ones = 0u64;
+
+        let mut i = 0usize;
+        for c in input.chars().rev() {
+
+            if c == '0'  {
+                zeros &= !(1 << i);
+            } else if c == '1' {
+                ones |= 1 << i;
+            }
+            i += 1;
+        }
+        return BitMask {
+            zeros_mask: zeros,
+            ones_mask: ones,
+        }
+
+    }
+
+
+    fn apply(&self, x: u64) -> u64 {
+        return (x & self.zeros_mask) | self.ones_mask;
+    }
+}
+
+struct MemoryBitMask {
+
+    ones_mask: u64,
+    ///Positions of the floating numbers
+    float_masks: Vec<u64>,
+
+}
+impl MemoryBitMask {
+
+    fn parse(input: &String) -> MemoryBitMask {
+
+        let mut ones = 0u64;
+        let mut float_masks: Vec<u64> = Vec::new();
+
+        let mut i = 0usize;
+        for c in input.chars().rev() {
+
+            if c == 'X'  {
+                float_masks.push(1 << i);
+            } else if c == '1' {
+                ones |= 1 << i;
+            }
+            i += 1;
+        }
+        return MemoryBitMask {
+            float_masks,
+            ones_mask: ones,
+        }
+
+    }
+
+    fn set_all(&self, pos: u64, n: u64, mem: &mut HashMap<u64, u64>) {
+
+        let base_pos = pos | self.ones_mask;
+        for float_opt in 0..(1 << self.float_masks.len()) {
+
+            let mut real_pos = base_pos;
+            for i in 0..self.float_masks.len() {
+
+                let float_mask = self.float_masks[i];
+                // Clear the bit in the original pos
+                real_pos &= !float_mask;
+                let bit_mask = 1 << i;
+                if float_opt & bit_mask != 0 {
+                    real_pos |= float_mask;
+                }
+            }
+            mem.insert(real_pos, n);
+        }
+    }
+}
+
+struct Instruction {
+    pos: usize,
+    n: u64,
+}
+
+impl Instruction {
+    fn parse(input: &String) -> Instruction {
+        let pos_start = input.find("[").unwrap() + 1;
+        let pos_end = input.find("]").unwrap();
+        let pos = input[pos_start..pos_end].parse::<usize>().unwrap();
+
+        let n_start = input.find(" = ").unwrap() + 3;
+        let n = input[n_start..].parse::<u64>().unwrap();
+
+        return Instruction { pos, n };
+    }
+}
--- a/src/day15.rs
+++ b/src/day15.rs
@@ -0,0 +1,41 @@
+use super::util;
+
+pub fn solve() {
+    let lines = util::read_file("input/day15.txt");
+    let starting_numbers = lines[0].split(",").map(|s| s.parse::<usize>().unwrap()).collect::<Vec<_>>();
+
+    let part1 = play_until(2020, &starting_numbers);
+    println!("Day X Part 1: {}", part1);
+
+
+    let part2 = play_until(30_000_000, &starting_numbers);
+    println!("Day X Part 2: {}", part2);
+}
+
+fn play_until(max_turn: usize, starting_numbers: &Vec<usize>) -> usize {
+
+    // Because numbers can never be bigger than the number of turns, this works:
+    let mut last_occurrence = vec!{0usize; max_turn};
+
+    // Note: we ignore the last number here; it will be the "previous_number" later.
+    for i in 0..(starting_numbers.len() - 1) {
+        let n = starting_numbers[i];
+        last_occurrence[n] = i + 1;
+    }
+
+    let mut previous_number = starting_numbers[starting_numbers.len() - 1];
+    for turn in starting_numbers.len()..max_turn {
+
+        let prev_occurrence = last_occurrence[previous_number];
+        last_occurrence[previous_number] = turn;
+        if prev_occurrence == 0 {
+            previous_number = 0;
+        } else {
+            previous_number = turn - prev_occurrence;
+        }
+        // println!("Turn {}: {}", turn + 1, previous_number);
+    }
+
+    return previous_number;
+
+}
--- a/src/day16.rs
+++ b/src/day16.rs
@@ -0,0 +1,212 @@
+use super::util;
+use std::cmp::{min, max};
+
+pub fn solve() {
+    let lines = util::read_file("input/day16.txt");
+
+    let range_sets = lines.iter().take_while(|s| !s.is_empty()).map(|s| ValidRangeSet::parse(s)).collect::<Vec<_>>();
+    let your_ticket = lines.iter().skip_while(|s| s != &"your ticket:").skip(1).next().unwrap()
+        .split(",").map(|s| s.parse::<u32>().unwrap()).collect::<Vec<u32>>();
+    let nearby_tickets = lines.iter().skip_while(|s| s != &"nearby tickets:").skip(1)
+        .map(|t| t.split(",").map(|s| s.parse::<u32>().unwrap()).collect::<Vec<_>>()).collect::<Vec<_>>();
+
+    let combined_ranges = ValidRange::combine(&range_sets.iter().flat_map(|r| &r.ranges).collect::<Vec<_>>());
+    let invalids_per_ticket = nearby_tickets.iter()
+        .map(|t| find_invalid(t, &combined_ranges))
+        .collect::<Vec<_>>();
+    // println!("{:?}", combined_ranges);
+
+    let part1: u32 = invalids_per_ticket.iter().map(|t| -> u32 { t.iter().sum() }).sum();
+    println!("Day X Part 1: {}", part1);
+
+    let mut valid_tickets = Vec::new();
+    for i in 0..nearby_tickets.len() {
+        if invalids_per_ticket[i].is_empty() {
+            valid_tickets.push(&nearby_tickets[i]);
+        }
+    }
+
+    let ordered_range_sets = resolve_column_ordering(&valid_tickets, &range_sets);
+    // println!("{:?}", ordered_range_sets);
+    let fields = ordered_range_sets.iter().map(|r| &r.name).filter(|n| n.starts_with("departure")).collect::<Vec<&String>>();
+    let part2 =
+        get_ticket_values(&your_ticket, &fields, &ordered_range_sets)
+            .iter()
+            .fold(1u64, |a, b| (a as u64) * (*b as u64));
+    println!("Day X Part 2: {}", part2);
+}
+
+fn find_invalid(nums: &Vec<u32>, combined_ranges: &Vec<ValidRange>) -> Vec<u32> {
+
+    return nums.iter().filter(|n| not_in_ranges(n, combined_ranges)).map(|n| n.clone().clone()).collect::<Vec<u32>>()
+
+}
+
+fn not_in_ranges(n: &u32, ranges: &Vec<ValidRange>) -> bool {
+
+    let closest_range_idx_res = ranges.binary_search_by_key(n, |r| r.min);
+    let closest_range_idx = if closest_range_idx_res.is_err() {
+        closest_range_idx_res.unwrap_err()
+    } else {
+        // If we're matching a range, the index will be the same as the range, but if we're not matching, it will be one higher
+        closest_range_idx_res.unwrap() + 1
+    };
+    let optimized_res = closest_range_idx == 0 || !ranges[closest_range_idx - 1].includes(n);
+    return optimized_res;
+}
+
+fn resolve_column_ordering(tickets: &Vec<&Vec<u32>>, range_sets: &Vec<ValidRangeSet>) -> Vec<ValidRangeSet> {
+
+    let mut available_order_per_range_set = Vec::new();
+    for _ in 0..range_sets.len() {
+        available_order_per_range_set.push(vec!{ true; range_sets.len() });
+    }
+    let mut solved_range_sets = vec!{ false; range_sets.len() };
+
+    for ticket in tickets {
+
+        for range_set_idx in 0..available_order_per_range_set.len() {
+
+            if solved_range_sets[range_set_idx] {
+                continue;
+            }
+            let range_set = &range_sets[range_set_idx];
+            let available_orders = &mut available_order_per_range_set[range_set_idx];
+            let mut removed_options = false;
+            for j in 0..available_orders.len() {
+                if available_orders[j] && !range_set.matches(&ticket[j]) {
+                    available_orders[j] = false;
+                    removed_options = true;
+                }
+            }
+            if removed_options {
+                check_options_left(range_set_idx, &mut solved_range_sets, &mut available_order_per_range_set);
+            }
+        }
+    }
+
+    let order_per_range_set = available_order_per_range_set.iter()
+        .inspect(|a| if a.iter().filter(|b| **b).count() > 1 { panic!(format!("Inconclusive in terms of ordering"))} )
+        .map(|a| a.iter().position(|b| *b).unwrap())
+        .collect::<Vec<usize>>();
+
+    // Sort the range sets so that they're in their available order
+    let mut res = vec!{ ValidRangeSet{ name: String::from("temp"), ranges: Vec::new() }; range_sets.len()};
+    for i in 0..range_sets.len() {
+        res[order_per_range_set[i]] = range_sets[i].clone();
+    }
+    return res;
+}
+
+fn check_options_left(orig_range_set_idx: usize, solved_range_sets: &mut Vec<bool>, available_order_per_range_set: &mut Vec<Vec<bool>>) {
+
+    let options_left = available_order_per_range_set[orig_range_set_idx].iter().filter(|o| **o).count();
+    if options_left == 1 {
+        // We now know for sure where range_set i is supposed to be, so we can cross
+        // that option out for all other range sets:
+        solved_range_sets[orig_range_set_idx] = true;
+        let known_order = available_order_per_range_set[orig_range_set_idx].iter().position(|o|*o).unwrap();
+
+        // println!("Original range set position '{}' must be position: {}", orig_range_set_idx, known_order);
+
+        for j in 0..available_order_per_range_set.len() {
+
+            if j == orig_range_set_idx { continue; }
+
+            if available_order_per_range_set[j][known_order] {
+                available_order_per_range_set[j][known_order] = false;
+                check_options_left(j, solved_range_sets, available_order_per_range_set);
+            }
+        }
+
+    } else if options_left == 0 {
+        panic!(format!("Couldn't find any valid ordering for range set {}", orig_range_set_idx));
+    }
+
+
+}
+
+fn get_ticket_values(ticket: &Vec<u32>, fields: &Vec<&String>, ordered_range_sets: &Vec<ValidRangeSet>) -> Vec<u32> {
+    let mut res = Vec::new();
+    for field in fields {
+
+        let idx = ordered_range_sets.iter().position(|r| &&r.name == field).unwrap();
+        res.push(ticket[idx]);
+    }
+    return res;
+
+}
+
+#[derive(Debug, Copy, Clone)]
+struct ValidRange {
+    min: u32,
+    max: u32
+}
+
+impl ValidRange {
+
+    fn parse(input: &str) -> ValidRange {
+        let values = input.split("-").map(|s| s.trim()).collect::<Vec<_>>();
+        return ValidRange {
+            min: values[0].parse::<u32>().unwrap(),
+            max: values[1].parse::<u32>().unwrap(),
+        }
+    }
+
+    fn includes(&self, n: &u32) -> bool {
+        return &self.min <= n && &self.max >= n;
+    }
+
+    fn combine(ranges: &Vec<&ValidRange>) -> Vec<ValidRange> {
+
+        let mut res = Vec::new();
+        for range in ranges {
+            let overlaps = res.iter().enumerate().filter(|(_, r)| range.overlaps(r))
+                .collect::<Vec<_>>();
+            let indices_to_remove = overlaps.iter().map(|(i, _)| i.clone()).rev().collect::<Vec<_>>();
+            if overlaps.len() == 0 {
+                res.push(ValidRange { min: range.min, max: range.max });
+            } else {
+
+                let combined_min = min(range.min, overlaps.iter().map(|(_, r)| r.min).min().unwrap());
+                let combined_max = max(range.max, overlaps.iter().map(|(_, r)| r.max).max().unwrap());
+                res.push(ValidRange { min: combined_min, max: combined_max })
+            }
+            for i in indices_to_remove {
+                res.remove(i);
+            }
+
+        }
+
+        res.sort_by_key(|r| r.min);
+        return res;
+
+    }
+
+    fn overlaps(&self, other: &ValidRange) -> bool {
+        return self.min <= other.max && self.max >= other.min;
+    }
+}
+
+#[derive(Debug, Clone)]
+struct ValidRangeSet {
+    name: String,
+    ranges: Vec<ValidRange>,
+}
+
+impl ValidRangeSet {
+    fn parse(input: &String) -> ValidRangeSet {
+
+        let spl = input.split(": ").collect::<Vec<_>>();
+        return ValidRangeSet {
+            name: String::from(spl[0]),
+            ranges: spl[1].split(" or ").map(|r| ValidRange::parse(r)).collect::<Vec<_>>()
+        }
+    }
+
+    fn matches(&self, n: &u32) -> bool {
+
+        return self.ranges.iter().any(|r| r.includes(n));
+
+    }
+}
--- a/src/day17.rs
+++ b/src/day17.rs
@@ -0,0 +1,272 @@
+use super::util;
+use std::cmp::{min, max};
+
+pub fn solve() {
+    let lines = util::read_file("input/day17.txt");
+
+    let initial_width = lines[0].len() as i32;
+    let initial_height = lines.len() as i32;
+
+    let cycles = 6;
+
+    // The grid grows by at most 1 index per cycle, so this should be big enough:
+    let lower = Vec4::of(-cycles-1, -cycles-1, -cycles-1, -cycles-1);
+    let upper = Vec4::of(initial_width + cycles+1, initial_height + cycles+1, cycles + 2, cycles + 2);
+
+    let mut initial_state = BoolGrid4D::new(lower, upper);
+    for y in 0..initial_height {
+        let mut line_chars = lines[y as usize].chars();
+
+        for x in 0..initial_width {
+
+            if line_chars.next().unwrap() == '#' {
+                initial_state.set(&x, &y, &0, &0, true);
+            }
+        }
+    }
+
+    let res1 = run_conway_cube_simulation(&initial_state, cycles as u32, true);
+
+    let part1: u32 = res1.data.data.iter().map(|c| c.count_ones()).sum();
+    println!("Day 17 Part 1: {}", part1);
+
+
+    let res2 = run_conway_cube_simulation(&initial_state, cycles as u32, false);
+    let part2: u32 = res2.data.data.iter().map(|c| c.count_ones()).sum();
+    println!("Day 17 Part 2: {}", part2);
+}
+
+fn run_conway_cube_simulation(initial_state: &BoolGrid4D, cycles: u32, restrict_fourth_dimension: bool) -> BoolGrid4D {
+
+    let mut prev_state = initial_state.clone();
+    let mut next_state = initial_state.clone();
+
+    let mut lower_activity = Vec4::of(initial_state.lower.x + 1, initial_state.lower.y + 1, initial_state.lower.z + 1,
+        if restrict_fourth_dimension { 0 } else { initial_state.lower.w + 1 });
+    let mut upper_activity = Vec4::of(initial_state.upper.x - 1, initial_state.upper.y - 1, initial_state.upper.z - 1,
+                                      if restrict_fourth_dimension { 1 } else { initial_state.upper.w - 1 });
+
+    for _cycle in 0..cycles {
+
+
+        let mut next_lower_activity = prev_state.upper.clone();
+        let mut next_upper_activity = prev_state.lower.clone();
+
+        if restrict_fourth_dimension {
+            next_lower_activity.w = 0;
+            next_upper_activity.w = 1;
+        }
+
+        for w in lower_activity.w..upper_activity.w {
+            for z in lower_activity.z..upper_activity.z {
+                for y in lower_activity.y..upper_activity.y {
+                    for x in lower_activity.x..upper_activity.x {
+
+                        let active_neighbors: usize = prev_state.count_active_neighbors(&x, &y, &z, &w, &restrict_fourth_dimension, 4);
+                        let active_self = prev_state.get(&x, &y, &z, &w);
+
+                        let active_next = (active_self && (active_neighbors == 2 || active_neighbors == 3)) || (!active_self && active_neighbors == 3);
+
+                        next_state.set(&x, &y, &z, &w, active_next);
+
+                        if active_next != active_self {
+                            next_lower_activity.x = min(next_lower_activity.x, x - 1);
+                            next_lower_activity.y = min(next_lower_activity.y, y - 1);
+                            next_lower_activity.z = min(next_lower_activity.z, z - 1);
+                            next_upper_activity.x = max(next_upper_activity.x, x + 2);
+                            next_upper_activity.y = max(next_upper_activity.y, y + 2);
+                            next_upper_activity.z = max(next_upper_activity.z, z + 2);
+                            if !restrict_fourth_dimension {
+                                next_lower_activity.w = min(next_lower_activity.w, w - 1);
+                                next_upper_activity.w = max(next_upper_activity.w, w + 2);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        lower_activity = next_lower_activity;
+        upper_activity = next_upper_activity;
+
+        // if !restrict_fourth_dimension {
+        //     println!("After {} cycles:", _cycle + 1);
+        //     next_state.print();
+        // }
+
+        if lower_activity.x >= upper_activity.x {
+            panic!("No activity!");
+        }
+
+        prev_state = next_state.clone();
+    }
+
+    return prev_state;
+
+}
+
+#[derive(Clone)]
+struct Vec4 {
+    x: i32,
+    y: i32,
+    z: i32,
+    w: i32
+}
+
+impl Vec4 {
+    fn of(x: i32, y: i32, z: i32, w: i32) -> Vec4 {
+        return Vec4 { x, y, z, w };
+    }
+}
+
+#[derive(Clone)]
+struct BoolGrid4D {
+
+    data: BitArray,
+    lower: Vec4,
+    upper: Vec4,
+    size: Vec4,
+}
+
+impl BoolGrid4D {
+
+    fn new(lower: Vec4, upper: Vec4) -> BoolGrid4D {
+
+        assert!(lower.x < upper.x && lower.y < upper.y && lower.z < upper.z);
+
+        let size = Vec4 {
+            x: upper.x - lower.x,
+            y: upper.y - lower.y,
+            z: upper.z - lower.z,
+            w: upper.w - lower.w
+        };
+
+        return BoolGrid4D {
+            data: BitArray::new((size.x * size.y * size.z * size.w) as usize, false),
+            lower, upper, size
+        }
+
+    }
+
+    fn get_idx(&self, x: &i32, y: &i32, z: &i32, w: &i32) -> usize {
+
+        assert!(x >= &self.lower.x && x < &self.upper.x);
+        assert!(y >= &self.lower.y && y < &self.upper.y);
+        assert!(z >= &self.lower.z && z < &self.upper.z);
+        assert!(w >= &self.lower.w && w < &self.upper.w);
+
+        return (x - self.lower.x) as usize +
+            (y - self.lower.y) as usize * self.size.x as usize +
+            (z - self.lower.z) as usize * self.size.x as usize  * self.size.y as usize +
+            (w - self.lower.w) as usize * self.size.x as usize  * self.size.y as usize * self.size.z as usize;
+    }
+
+    fn get(&self, x: &i32, y: &i32, z: &i32, w: &i32) -> bool {
+        return self.data.get(self.get_idx(x, y, z, w));
+    }
+
+    fn set(&mut self, x: &i32, y: &i32, z: &i32, w: &i32, v: bool) {
+        let idx = self.get_idx(x, y, z, w);
+        self.data.set(idx, v);
+    }
+
+    fn count_active_neighbors(&self, x: &i32, y: &i32, z: &i32, w: &i32, restrict_fourth_dimension: &bool, count_until: usize) -> usize {
+
+        assert!(x - 1 >= self.lower.x && x + 1 < self.upper.x);
+        assert!(y - 1 >= self.lower.y && y + 1 < self.upper.y);
+        assert!(z - 1 >= self.lower.z && z + 1 < self.upper.z);
+        assert!(w - 1 >= self.lower.w && w + 1 < self.upper.w);
+
+        let mut res = 0;
+        for nw in if *restrict_fourth_dimension { *w..w+1 } else { w-1..w+2 } {
+            for nz in z - 1..z + 2 {
+                for ny in y - 1..y + 2 {
+                    for nx in x - 1..x + 2 {
+
+                        // Skip self (i.e. not the neighbor)
+                        if &nz == z && &ny == y && &nx == x && &nw == w { continue };
+
+                        if self.get(&nx, &ny, &nz, &nw) {
+                            res += 1;
+                            if res >= count_until {
+                                return res;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return res;
+    }
+
+    #[allow(dead_code)]
+    fn print(&self) {
+
+        for w in self.lower.w..self.upper.w {
+
+            if !self.any_in_w(&w) { continue; }
+            for z in self.lower.z..self.upper.z {
+
+                if !self.any_in_wz(&w, &z) { continue; }
+                println!("z={}, w={}", z, w);
+                for y in self.lower.y..self.upper.y {
+                    for x in self.lower.x..self.upper.x {
+                        print!("{}", if self.get(&x, &y, &z, &0) { '#' } else { '.' });
+                    }
+                    println!();
+                }
+            }
+        }
+    }
+
+    fn any_in_w(&self, w: &i32) -> bool {
+
+        for i in self.get_idx(&self.lower.x, &self.lower.y, &self.lower.z, w)..
+            (self.get_idx(&(self.upper.x - 1), &(self.upper.y - 1), &(self.upper.z - 1), w) + 1) {
+            if self.data.get(i) { return true; }
+        }
+        return false;
+    }
+
+    fn any_in_wz(&self, w: &i32, z: &i32) -> bool {
+
+        for i in self.get_idx(&self.lower.x, &self.lower.y, z, w)..
+            (self.get_idx(&(self.upper.x - 1), &(self.upper.y - 1), z, w) + 1) {
+            if self.data.get(i) { return true; }
+        }
+        return false;
+    }
+
+}
+
+#[derive(Clone)]
+struct BitArray {
+    data: Vec<u32>,
+    length: usize,
+}
+
+impl BitArray {
+
+    fn new(length: usize, default: bool) -> BitArray {
+        return BitArray{
+            data: vec!{if default { !0 } else { 0 }; (length / 32) + 1},
+            length,
+        }
+    }
+
+    fn get(&self, i: usize) -> bool {
+        return BitArray::get_bit(&self.data[i / 32], &(i % 32));
+    }
+
+    fn get_bit(d: &u32, i: &usize) -> bool {
+        return d & (1 << i) != 0
+    }
+
+    fn set(&mut self, i: usize, v: bool) {
+
+        let mask = 1 << (i % 32);
+        self.data[i / 32] &= !mask;
+        if v { self.data[i / 32] |= mask; }
+    }
+
+}
--- a/src/day18.rs
+++ b/src/day18.rs
@@ -0,0 +1,202 @@
+use super::util;
+
+pub fn solve() {
+    let lines = util::read_file("input/day18.txt");
+
+    // lines.iter()
+    //     .for_each(|s| println!("{} = {}", s, evaluate(s.as_str()).0));
+
+    let part1: u64 = lines.iter().map(|s| evaluate(s.as_str()).0).sum();
+    println!("Day X Part 1: {}", part1);
+
+
+    let part2: u64 = lines.iter()
+        // .inspect(|s| println!("{}: {}", s, build_expression_tree(s.as_str()).0.evaluate()))
+        .map(|s| build_expression_tree(s.as_str()).0.evaluate())
+        .sum();
+    println!("Day X Part 2: {}", part2);
+}
+
+fn evaluate(input: &str) -> (u64, usize) {
+
+    let mut i = 0usize;
+    let mut res = 0;
+    let mut operator = Operator::Add;
+    while i < input.len() {
+
+        let c = &input[i..(i+1)];
+        if c == "(" {
+            let sub_evaluation = evaluate(&input[(i + 1)..]);
+            i += sub_evaluation.1;
+            res = operator.apply(res, sub_evaluation.0);
+        } else if c == ")" {
+            return (res, i + 1);
+        } else if c == "+" {
+            operator = Operator::Add;
+        } else if c == "*" {
+            operator = Operator::Multiply;
+        } else if c == " " {
+            // Nothing to do
+        } else {
+            let n = c.parse::<u64>().unwrap();
+            res = operator.apply(res, n);
+        }
+        i += 1;
+    }
+
+    return (res, i);
+}
+
+fn build_expression_tree(input: &str) -> (ExpressionTreeNode, usize) {
+
+    // println!("Evaluating '{}':", input);
+
+    let mut subtrees: Vec<(usize, usize, ExpressionTreeNode)> = Vec::new();
+    let mut evaluate_until = input.len();
+    {
+        let mut i = 0;
+        // First build subtrees for brackets:
+        while i < evaluate_until {
+            let par_open = input[i..evaluate_until].find("(").map(|p| i + p);
+            let par_close = input[i..evaluate_until].find(")").map(|p| i + p);
+            if par_open.is_some() && par_close.unwrap() > par_open.unwrap() {
+                let subtree_start = par_open.unwrap();
+                let subtree = build_expression_tree(&input[(subtree_start + 1)..]);
+                let subtree_end = subtree_start + subtree.1 + 1;
+                subtrees.push((subtree_start, subtree_end, subtree.0));
+                i = subtree_end + 1;
+            } else {
+                if par_close.is_some() {
+                    // If we find a closing parenthesis, we're apparently building a subtree
+                    evaluate_until = par_close.unwrap();
+                    break;
+                } else {
+                    // No parenthesis, so no need to search further
+                    break;
+                }
+            }
+        }
+    }
+
+    // println!("Subtrees between parentheses in '{}':", &input[0..evaluate_until]);
+    // subtrees.iter().for_each(|s| println!("{:?}", s));
+
+
+    // Now we're gonna match/find all +:
+    build_subtrees_for_operators(input, 0, evaluate_until, "+", &Operator::Add, &mut subtrees);
+    build_subtrees_for_operators(input, 0, evaluate_until, "*", &Operator::Multiply, &mut subtrees);
+
+    // // By now we should have a single root node left
+    // println!("Subtrees in '{}':", &input[0..evaluate_until]);
+    // subtrees.iter().for_each(|s| println!("{:?}", s));
+
+    assert_eq!(subtrees.len(), 1);
+    return (subtrees.remove(0).2, evaluate_until);
+
+}
+
+fn is_not_whitespace(c: char) -> bool {
+    return !c.is_whitespace();
+}
+
+fn build_subtrees_for_operators(input: &str, from: usize, until: usize, operator_symbol: &str, operator: &Operator, subtrees: &mut Vec<(usize, usize, ExpressionTreeNode)>) {
+
+    let mut i = if subtrees.is_empty() || subtrees[0].0 > from { 0 } else { subtrees[0].1 + 1 };
+    // Subtree index points to the subtree after the current search-range
+    let mut subtree_idx = if i == 0 { 0 } else { 1 };
+    let mut search_until = if subtrees.is_empty() { until } else if subtree_idx < subtrees.len() { subtrees[subtree_idx].0 } else { until };
+    while i < until {
+        let operator_idx = input[i..search_until].find(operator_symbol).map(|r| i + r);
+        if operator_idx.is_some() {
+            // Found the operator symbol, let's build a subtree with whatever is left and right of it:
+            let subtree_end = build_subtree_for_operator(operator_idx.unwrap(), &input, operator, subtrees);
+            i = subtree_end + 1;
+            if i > search_until {
+                // Our newly build subtree includes the last search range:
+                search_until = subtrees.iter().map(|s| s.0).find(|s| s > &i).unwrap_or(until);
+            }
+        } else {
+            subtree_idx += 1;
+            // If the subtree_idx points the to subtree "after" the last one, that just means to search until the end of the string
+            // If the subtree_idx points even after that, then we're done.
+            if subtree_idx > subtrees.len() {
+                break;
+            }
+            i = subtrees[subtree_idx - 1].1;
+            search_until = if subtrees.is_empty() { until } else if subtree_idx < subtrees.len() { subtrees[subtree_idx].0 } else { until };
+            if i == search_until {
+                break;
+            }
+        }
+    }
+}
+
+fn build_subtree_for_operator(idx: usize, input: &str, op: &Operator, subtrees: &mut Vec<(usize, usize, ExpressionTreeNode)>) -> usize {
+
+    let left_idx = input[0..idx].rfind(is_not_whitespace).unwrap();
+    let right_idx = idx + 1 + input[(idx + 1)..].find(is_not_whitespace).unwrap();
+
+    let left_subtree = subtrees.binary_search_by_key(&left_idx, |s| s.1);
+    let right_subtree = subtrees.binary_search_by_key(&right_idx, |s| s.0);
+    let subtree_start = if left_subtree.is_ok() { subtrees[left_subtree.unwrap()].0 } else {left_idx};
+    let subtree_end = if right_subtree.is_ok() { subtrees[right_subtree.unwrap()].1 } else {right_idx};
+    let subtree = ExpressionTreeNode {
+        operator: Option::Some(op.clone()),
+        right: Option::Some(Box::from( if right_subtree.is_ok() { subtrees.remove(right_subtree.unwrap()).2 } else { ExpressionTreeNode::leaf_node(&input[right_idx..(right_idx+ 1)]) })),
+        left: Option::Some( Box::from(if left_subtree.is_ok() { subtrees.remove(left_subtree.unwrap()).2 } else { ExpressionTreeNode::leaf_node(&input[left_idx..(left_idx + 1)]) })),
+        num: Option::None,
+    };
+
+    let insertion_index = if subtrees.is_empty() { 0 } else {
+        let res = subtrees.binary_search_by_key(&subtree_start, |s| s.0);
+        if res.is_ok() { res.unwrap() } else { res.unwrap_err() }
+    };
+    subtrees.insert(insertion_index, (subtree_start, subtree_end, subtree));
+    return subtree_end;
+}
+
+#[derive(Debug, PartialEq, Clone)]
+enum Operator {
+    Multiply, Add
+}
+
+
+impl Operator {
+    fn apply(&self, x: u64, y: u64) -> u64 {
+        return match self {
+            Operator::Add => x + y,
+            Operator::Multiply => x * y
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ExpressionTreeNode {
+
+    operator: Option<Operator>,
+    num: Option<u64>,
+    left: Option<Box<ExpressionTreeNode>>,
+    right: Option<Box<ExpressionTreeNode>>,
+
+}
+
+impl ExpressionTreeNode {
+
+    fn leaf_node(input: &str) -> ExpressionTreeNode {
+        return ExpressionTreeNode {
+            operator: Option::None,
+            left: Option::None,
+            right: Option::None,
+            num: Option::Some(input.parse::<u64>().unwrap())
+        };
+    }
+
+    fn evaluate(&self) -> u64 {
+
+        return if self.num.is_some() {
+            self.num.unwrap()
+        } else {
+            self.operator.as_ref().unwrap().apply(self.left.as_ref().unwrap().evaluate(), self.right.as_ref().unwrap().evaluate())
+        }
+    }
+}
--- a/src/day19.rs
+++ b/src/day19.rs
@@ -0,0 +1,112 @@
+use super::util;
+use regex::Regex;
+use crate::day19::RuleType::{Letter, Options};
+use std::collections::{HashMap, HashSet};
+
+pub fn solve() {
+    let lines = util::read_file("input/day19.txt");
+    let mut rules_map = HashMap::new();
+    lines.iter()
+        .take_while(|s| s != &&String::from(""))
+        .for_each(|s| {
+            let mut line_split = s.split(": ");
+            let idx = line_split.next().unwrap().parse::<usize>().unwrap();
+            let rule = Rule::parse(line_split.next().unwrap());
+            rules_map.insert(idx, rule);
+        });
+
+    let messages: Vec<&String> = lines[(rules_map.len() + 1)..].iter().collect();
+
+    println!("{:?}", try_match(&messages[0], &0, &rules_map));
+    let part1 = messages.iter().filter(|m| try_match(m, &0, &rules_map).contains(&m.len())).count();
+    println!("Day X Part 1: {}", part1);
+
+    // We update the rules to include the loops:
+    rules_map.insert(8, Rule::parse("42 | 42 8"));
+    rules_map.insert(11, Rule::parse("42 31 | 42 11 31"));
+
+
+    let part2 = messages.iter().filter(|m| try_match(m, &0, &rules_map).contains(&m.len())).count();
+    println!("Day X Part 2: {}", part2);
+}
+
+/// Calculates and returns until when the string was matched
+fn try_match(message: &str, rule_idx: &usize, rules: &HashMap<usize, Rule>) -> HashSet<usize> {
+
+    let rule = rules.get(&rule_idx).unwrap();
+    if rule.rule_type == Letter {
+
+        if message.starts_with(rule.letters.as_ref().unwrap()) {
+            let mut res = HashSet::new();
+            // Note: kind of a hack here, all the "letter" based matchers are of length 1
+            res.insert(rule.letters.as_ref().unwrap().len().clone());
+            return res;
+        } else {
+            return HashSet::new();
+        }
+
+    } else {
+
+        return rule.options.as_ref().unwrap().iter()
+            .flat_map(|options| {
+                let mut try_from = HashSet::new();
+                try_from.insert(0);
+                let mut next_try_from = HashSet::new();
+                for option_rule_idx in options {
+                    for start_idx in try_from {
+                        try_match(&message[start_idx..], &option_rule_idx, rules)
+                            .iter()
+                            .for_each(|m| { if m != &0 { next_try_from.insert(start_idx + m); () }})
+
+                    }
+                    try_from = next_try_from.clone();
+                    if try_from.is_empty() { break; }
+                    next_try_from.clear();
+                }
+                return try_from;
+            }).collect();
+    }
+
+}
+
+#[derive(Debug, Clone)]
+struct Rule {
+
+    rule_type: RuleType,
+    letters: Option<String>,
+    options: Option<Vec<Vec<usize>>>
+
+}
+
+impl  Rule {
+
+    fn parse(input: &str) -> Rule {
+
+        lazy_static! {
+            static ref LETTER_RULE_MATCHER: Regex = Regex::new(r###"^"([a-z])"$"###).unwrap();
+        }
+        return if LETTER_RULE_MATCHER.is_match(input) {
+            Rule {
+                rule_type: Letter,
+                letters: Option::Some(LETTER_RULE_MATCHER.captures(input).unwrap().get(1).map(|m| String::from(m.as_str())).unwrap()),
+                options: Option::None,
+            }
+        } else {
+            let options =
+                input.split(" | ")
+                    .map(|s| s.split(" ").map(|o| o.parse::<usize>().unwrap()).collect::<Vec<_>>()).collect::<Vec<_>>();
+            Rule {
+                rule_type: Options,
+                letters: Option::None,
+                options: Option::Some(options)
+            }
+        }
+
+
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+enum RuleType {
+    Letter, Options
+}
--- a/src/day20.rs
+++ b/src/day20.rs
@@ -0,0 +1,240 @@
+use super::util;
+use std::collections::HashMap;
+
+const PIECE_SIZE: u16 = 10;
+// const POSSIBLE_EDGE_COUNT: u16 = 1 << (PIECE_SIZE + 1);
+
+pub fn solve() {
+    let lines = util::read_file("input/day20.txt");
+    let mut piece_id = 0u32;
+    let mut piece_lines: Vec<PieceLine> = Vec::new();
+    let mut pieces = Vec::new();
+    for line in &lines {
+
+        if line == &"" {
+            pieces.push(Piece::from(piece_id, piece_lines));
+            piece_lines = Vec::new();
+        } else if line.starts_with("Tile") {
+            piece_id = line[5..(line.len() - 1)].parse::<u32>().unwrap();
+        } else {
+            piece_lines.push(PieceLine::parse(&line));
+        }
+    }
+    if !piece_lines.is_empty() {
+        pieces.push(Piece::from(piece_id, piece_lines));
+    }
+    pieces.sort_by_key(|p| p.id);
+
+    // Let's create an array containing for each puzzle piece side, in which pieces it appears:
+    let mut piece_matches = HashMap::new();
+    for piece in &pieces {
+        add_to_piece_matches(piece.id, &piece.top_edge, &piece.flipped_top_edge, &mut piece_matches);
+        add_to_piece_matches(piece.id, &piece.bottom_edge, &piece.flipped_bottom_edge, &mut piece_matches);
+        add_to_piece_matches(piece.id, &piece.left_edge, &piece.flipped_left_edge, &mut piece_matches);
+        add_to_piece_matches(piece.id, &piece.right_edge, &piece.flipped_right_edge, &mut piece_matches);
+    }
+
+    // println!("{:?}", piece_matches);
+
+    // And now we find which pieces are adjacent (same edge) to which other pieces (not caring about orientation at all)
+    let mut matched_edge_count: HashMap<u32, usize> = HashMap::new();
+    for piece_match in piece_matches {
+        if piece_match.1.len() == 1 {
+            continue;
+        }
+        piece_match.1.iter().for_each(|m| { matched_edge_count.entry(m.clone()).and_modify(|c| *c += 1 ).or_insert(1); })
+    }
+
+    println!("{:?}", matched_edge_count);
+    let corner_pieces: Vec<u32> = matched_edge_count.iter().filter(|e| e.1 == &2).map(|e| e.0.clone()).collect::<Vec<_>>();
+
+    assert_eq!(corner_pieces.len(), 4);
+
+    let part1 = corner_pieces.iter().fold(1u64, |a, b| a as u64 * b.clone() as u64);
+    println!("Day X Part 1: {}", part1);
+
+
+    let part2 = 0;
+    println!("Day X Part 2: {}", part2);
+}
+
+#[allow(dead_code)]
+fn make_puzzle(pieces: &HashMap<u32, Piece>, piece_matches: &HashMap<u16, Vec<u32>>, matched_edge_count: &HashMap<u32, usize>) {
+
+    let corner_pieces = matched_edge_count.iter().filter(|e| e.1 == &2).map(|e| e.0.clone()).collect::<Vec<u32>>();
+    let edge_pieces = matched_edge_count.iter().filter(|e| e.1 == &3).map(|e| e.0.clone()).collect::<Vec<u32>>();
+    let center_pieces = matched_edge_count.iter().filter(|e| e.1 == &4).map(|e| e.0.clone()).collect::<Vec<u32>>();
+
+    let mut puzzle = Puzzle { state: Vec::new() };
+
+
+    // First let's make the edges:
+    let first_corner_piece = pieces.get(&corner_pieces[0]);
+    // TODO Find out what side of the corner pieces were matched and orient it correctly:
+
+
+    // let last_piece = pieces.get(&corner_pieces[0]).unwrap();
+    // let last_piece_state = PieceState {
+    //     piece_id: corner_pieces[0],
+    //     degrees: 0,
+    //     flip_horizontal: false,
+    //     flip_vertical: false
+    // };
+    // puzzle.pieces.push(vec![Option::Some(last_piece_state)]);
+    // loop {
+    //
+    //
+    // }
+}
+
+fn add_to_piece_matches(piece_id: u32, edge: &PieceLine, flipped_edge: &PieceLine, piece_matches: &mut HashMap<u16, Vec<u32>>) {
+
+    let use_flipped = flipped_edge.data < edge.data;
+    let bookkeeping_edge = if use_flipped { flipped_edge } else { edge };
+
+    piece_matches.entry(bookkeeping_edge.data).and_modify(|d| d.push(piece_id)).or_insert(vec![ piece_id ]);
+}
+
+#[derive(Debug, Clone)]
+struct Puzzle {
+    state: Vec<Vec<Option<PieceState>>>
+}
+
+#[derive(Debug, Clone)]
+struct PieceState {
+    // 0, 90, 180 or 270
+    piece_id: u32,
+    degrees: u16,
+    flipped: bool,
+
+}
+
+impl PieceState {
+
+    /// Returns the edge on the right, given the current piece state (i.e. this might be actually the edge on top or a flipped
+    /// edge depending on the rotation
+    fn right_edge<'piece>(&self, piece: &'piece Piece) -> &'piece PieceLine {
+
+        return match self.degrees {
+            0 =>
+                if self.flipped {
+                    &piece.left_edge
+                } else {
+                    &piece.right_edge
+                }
+            90 =>
+                if self.flipped {
+                    &piece.flipped_top_edge
+                } else {
+                    &piece.top_edge
+                }
+            180 => {
+                if self.flipped {
+                    &piece.flipped_right_edge
+                } else {
+                    &piece.flipped_left_edge
+                }
+            }
+            270 => {
+                if self.flipped {
+                    &piece.bottom_edge
+                } else {
+                    &piece.flipped_bottom_edge
+                }
+            }
+            _ => panic!("Unsupported rotation")
+        }
+
+    }
+
+}
+
+#[derive(Debug, Clone)]
+struct Piece {
+
+    id: u32,
+    piece_lines: Vec<PieceLine>,
+
+    // left to right top edge
+    top_edge: PieceLine,
+    // left to right bottom edge
+    bottom_edge: PieceLine,
+    // Left edge (from top to bottom)
+    left_edge: PieceLine,
+    // Right edge (from to to bottom)
+    right_edge: PieceLine,
+    // Right to left top edge
+    flipped_top_edge: PieceLine,
+    // Right to left bottom edge
+    flipped_bottom_edge: PieceLine,
+    // Bottom to top left edge
+    flipped_left_edge: PieceLine,
+    // Bottom to top right edge
+    flipped_right_edge: PieceLine,
+
+}
+
+impl Piece {
+
+    fn from(id: u32, piece_lines: Vec<PieceLine>) -> Piece {
+
+        let top_edge = piece_lines[0].clone();
+        let bottom_edge = piece_lines[(PIECE_SIZE - 1) as usize].clone();
+        let left_edge = Piece::get_vertical(0, &piece_lines);
+        let right_edge = Piece::get_vertical(PIECE_SIZE - 1, &piece_lines);
+
+        return Piece {
+            id, piece_lines,
+            flipped_top_edge: top_edge.flipped(), flipped_bottom_edge: bottom_edge.flipped(),
+            flipped_left_edge: left_edge.flipped(), flipped_right_edge: right_edge.flipped(),
+            top_edge, bottom_edge, left_edge, right_edge,
+        };
+    }
+
+    fn get_vertical(x: u16, piece_lines: &Vec<PieceLine>) -> PieceLine {
+        let mut vert = 0;
+        for i in 0..PIECE_SIZE {
+            if piece_lines[i as usize].get(x as usize) {
+                vert |= 1 << i;
+            }
+        }
+        return PieceLine { data: vert };
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+struct PieceLine {
+    data: u16,
+}
+
+impl PieceLine {
+    fn parse(line: &String) -> PieceLine {
+
+        let mut data = 0u16;
+        let mut i = 0;
+        for char in line.chars() {
+            if char == '#' {
+                data |= 1 << i;
+            }
+            i += 1;
+        }
+
+        return PieceLine { data };
+    }
+
+    fn get(&self, i: usize) -> bool {
+
+        let mask = 1u16 << i;
+        return self.data & mask == mask;
+    }
+
+    fn flipped(&self) -> PieceLine {
+        let mut res = 0u16;
+        for i in 0..PIECE_SIZE {
+            if self.get(i as usize) {
+                res |= 1 << (PIECE_SIZE - i - 1)
+            }
+        }
+        return PieceLine { data: res };
+    }
+}
--- a/src/day21.rs
+++ b/src/day21.rs
@@ -0,0 +1,89 @@
+use super::util;
+use std::collections::{HashSet, HashMap};
+use std::iter::FromIterator;
+
+pub fn solve() {
+    let lines = util::read_file("input/day21.txt");
+
+    let recipes = lines.iter().map(Recipe::parse).collect::<Vec<Recipe>>();
+    // println!("{:?}", recipes);
+
+    // An ingredient that contains an allergen, must appear in all recipes that list that allergen.
+    // So all ingredients that don't appear in any such intersections, cannot contain allergens.
+    let mut allergens = recipes.iter().flat_map(|r| &r.allergens).collect::<Vec<&String>>();
+    allergens.sort();
+    allergens.dedup();
+
+    // println!("{:?}", allergens);
+
+    let mut possible_ingredients_per_allergen: HashMap<&String, Vec<&String>> = HashMap::new();
+
+    for allergen in &allergens {
+
+        let matching_recipes = recipes.iter()
+            .filter(|r| r.allergens.contains(allergen))
+            .collect::<Vec<&Recipe>>();
+
+        let mut matching_ingredients = matching_recipes[0].ingredients.iter().collect::<Vec<&String>>();
+        for recipe in matching_recipes[1..].iter() {
+            matching_ingredients = matching_ingredients.iter().filter(|i| recipe.ingredients.contains(**i)).map(|i| *i).collect();
+        }
+        possible_ingredients_per_allergen.insert(allergen, matching_ingredients);
+    }
+
+    // println!("{:?}", possible_ingredients_per_allergen);
+
+    // Now all the ingredients that are not "possible ingredients per allergen" can not possibly contain an allergen, so we count those instances:
+    let allergy_ingredients: HashSet<&String> = HashSet::from_iter(possible_ingredients_per_allergen.iter()
+        .flat_map(|e| e.1.iter()).map(|i|*i));
+
+    let part1: usize = recipes.iter().map(|r| r.ingredients.iter().filter(|i| !allergy_ingredients.contains(i)).count()).sum();
+    println!("Day 21 Part 1: {}", part1);
+
+    let mut remaining_ingredients_per_allergen: Vec<(&String, Vec<&String>)> = possible_ingredients_per_allergen.iter()
+        .map(|e| (*e.0, e.1.iter().map(|i|*i).collect()))
+        .collect();
+    let mut allergen_to_ingredient: HashMap<String, String> = HashMap::new();
+    loop {
+        let known_allergens: Vec<(String, String)> = remaining_ingredients_per_allergen.iter()
+            .filter(|e| e.1.len() == 1)
+            .map(|e| ((*e.0).clone(), e.1[0].clone())).collect();
+
+        for known_allergen in known_allergens {
+
+
+            remaining_ingredients_per_allergen = remaining_ingredients_per_allergen
+                .iter().filter(|e| e.0 != &known_allergen.0)
+                .map(|e| (e.0, e.1.iter().filter(|i| &known_allergen.1 != **i).map(|i| *i).collect()))
+                .collect();
+
+            allergen_to_ingredient.insert(known_allergen.0, known_allergen.1);
+        }
+
+        if remaining_ingredients_per_allergen.is_empty() {
+            break;
+        }
+    }
+
+    let dangerous_ingredients = allergens.iter().map(|a| allergen_to_ingredient.get(*a).unwrap().clone()).collect::<Vec<String>>();
+    let part2 = dangerous_ingredients.join(",");
+    println!("Day 21 Part 2: {}", part2);
+}
+
+#[derive(Debug, Clone)]
+struct Recipe {
+    ingredients: HashSet<String>,
+    allergens: Vec<String>
+}
+
+impl Recipe {
+
+    fn parse(line: &String) -> Recipe {
+
+        let allergens_idx = line.find("(contains ").unwrap();
+        let ingredients = HashSet::from(line[0..allergens_idx - 1].split(char::is_whitespace).map(|i| String::from(i)).collect());
+        let allergens = line[allergens_idx + "(contains ".len()..line.len() - 1].split(", ").map(String::from).collect::<Vec<String>>();
+
+        return Recipe { ingredients, allergens };
+    }
+}
--- a/src/day22.rs
+++ b/src/day22.rs
@@ -0,0 +1,111 @@
+use super::util;
+use std::collections::{VecDeque, HashSet};
+
+pub fn solve() {
+    let lines = util::read_file("input/day22.txt");
+    let p1_cards = lines.iter().skip(1)
+        .take_while(|s| s != &"")
+        .map(|s| s.parse::<u32>().unwrap())
+        .collect();
+
+    let p2_cards = lines.iter().skip_while(|s| s != &"Player 2:")
+        .skip(1)
+        .map(|s| s.parse::<u32>().unwrap())
+        .collect();
+
+    let part1 = play_combat(&p1_cards, &p2_cards);
+    println!("Day 22 Part 1: {}", part1);
+
+
+    let part2 = play_recursive_combat(&p1_cards, &p2_cards);
+    println!("Day 22 Part 2: {}", part2.1);
+}
+
+fn play_combat(p1_cards: &Vec<u32>, p2_cards: &Vec<u32>) -> u32 {
+
+    let mut p1_stack = VecDeque::from(p1_cards.clone());
+    let mut p2_stack = VecDeque::from(p2_cards.clone());
+
+    loop {
+        let p1_card = p1_stack.pop_front();
+        if !p1_card.is_some() {
+            return calculate_score(&p2_stack);
+        }
+        let p2_card = p2_stack.pop_front();
+        if !p2_card.is_some() {
+            // Push the card back on the stack
+            p1_stack.push_front(p1_card.unwrap());
+            return calculate_score(&p1_stack);
+        }
+
+        if p1_card.unwrap() > p2_card.unwrap() {
+            p1_stack.push_back(p1_card.unwrap());
+            p1_stack.push_back(p2_card.unwrap());
+        } else {
+            p2_stack.push_back(p2_card.unwrap());
+            p2_stack.push_back(p1_card.unwrap());
+        }
+    }
+}
+
+fn play_recursive_combat(p1_cards: &Vec<u32>, p2_cards: &Vec<u32>) -> (u32, u32) {
+
+    let mut p1_stack = VecDeque::from(p1_cards.clone());
+    let mut p2_stack = VecDeque::from(p2_cards.clone());
+
+    let mut known_configurations = HashSet::new();
+
+    loop {
+        // TODO: Find a quick way to check if we already found this configuration before
+        let config = (p1_stack.clone(), p2_stack.clone());
+        if known_configurations.contains(&config) {
+            // Player 1 wins by infinite loop protection:
+            return (1, calculate_score(&p1_stack));
+        }
+        known_configurations.insert(config);
+
+        let p1_card = p1_stack.pop_front();
+        if !p1_card.is_some() {
+            return (2, calculate_score(&p2_stack));
+        }
+        let p2_card = p2_stack.pop_front();
+        if !p2_card.is_some() {
+            // Push the card back on the stack
+            p1_stack.push_front(p1_card.unwrap());
+            return (1, calculate_score(&p1_stack));
+        }
+
+        let winning_player;
+        if p1_card.unwrap() as usize <= p1_stack.len() && p2_card.unwrap() as usize <= p2_stack.len() {
+            // Let's play a recursive round:
+            let recursive_result = play_recursive_combat(
+                &p1_stack.iter().take(p1_card.unwrap() as usize).map(|n| n.clone()).collect(),
+                &p2_stack.iter().take(p2_card.unwrap() as usize).map(|n| n.clone()).collect::<Vec<u32>>());
+            winning_player = recursive_result.0;
+        } else {
+            if p1_card.unwrap() > p2_card.unwrap() {
+                winning_player = 1;
+            } else {
+                winning_player = 2;
+            }
+        }
+
+        if winning_player == 1 {
+            p1_stack.push_back(p1_card.unwrap());
+            p1_stack.push_back(p2_card.unwrap());
+        } else if winning_player == 2 {
+            p2_stack.push_back(p2_card.unwrap());
+            p2_stack.push_back(p1_card.unwrap());
+        } else {
+            panic!("No winner!");
+        }
+    }
+}
+
+fn calculate_score(stack: &VecDeque<u32>) -> u32 {
+
+    return stack.iter().rev().enumerate()
+        .map(|c| (c.0 + 1) as u32 * c.1)
+        .sum();
+
+}
--- a/src/day23.rs
+++ b/src/day23.rs
@@ -0,0 +1,84 @@
+use super::util;
+use std::collections::LinkedList;
+use std::iter::FromIterator;
+use std::convert::TryFrom;
+use std::intrinsics::copy;
+
+pub fn solve() {
+    let lines = util::read_file("input/day23.txt");
+    let input = lines.first().unwrap().chars().map(|c| (c  as u8 - '0' as u8)).collect::<Vec<u8>>();
+
+    let result = play_game(<&[u8; 9]>::try_from(&input[0..]).unwrap(), 100);
+    let part1 = reorder_starting_from(&result, 1).iter().take(8).map(|s| s.to_string()).collect::<Vec<String>>().join("");
+    println!("Day 23 Part 1: {}", part1);
+
+
+    let part2 = 0;
+    println!("Day 23 Part 2: {}", part2);
+}
+
+fn play_game(input: &[u8; 9], rounds: u64) -> [u8; 9] {
+
+    let max_cup = input.iter().max().unwrap().clone();
+    let min_cup = input.iter().min().unwrap().clone();
+    let len = input.len();
+    let mut cur_order = input.clone();
+    let mut next_order = input.clone();
+    let mut cur_idx = 0usize;
+    for _ in 0..rounds {
+
+        let cur_label = &cur_order[cur_idx];
+        let mut dest_label = if cur_label == &min_cup { max_cup } else { cur_label - 1 };
+        let mut dest_idx = index_of(&cur_order, &dest_label);
+        let mut looped_dest_idx = if dest_idx < cur_idx { dest_idx + input.len() } else { dest_idx };
+
+        while looped_dest_idx > cur_idx && looped_dest_idx <= cur_idx + 3 {
+            dest_label = if dest_label == min_cup { max_cup } else { dest_label - 1 };
+            dest_idx = index_of(&cur_order, &dest_label);
+            looped_dest_idx = if dest_idx < cur_idx { dest_idx + input.len() } else { dest_idx };
+        }
+
+
+        // First copy the part from the end of the "picked up" cups to the destination
+        for i in cur_idx + 4..looped_dest_idx + 1 {
+            next_order[(i - 3) % len] = cur_order[i % len];
+        }
+
+        // Then copy the picked up cups to the destination
+        for i in 0..3 {
+            next_order[(looped_dest_idx - 2 + i) % len] = cur_order[(cur_idx + 1 + i) % len];
+        }
+
+        // println!("{:?}", next_order);
+        for c in input {
+            assert!(next_order.contains(c), format!("Lost {} while playing with index {} and destination label {}, dest index {}", c, cur_idx, dest_label, dest_idx));
+        }
+
+        // The rest should already be in the correct order
+        cur_order = next_order.clone();
+
+        cur_idx = (cur_idx + 1) % input.len();
+    }
+
+    return cur_order;
+}
+
+fn index_of(cups: &[u8;9], cup: &u8) -> usize {
+    for i in 0..cups.len() {
+        if &cups[i] == cup {
+            return i;
+        }
+    }
+    panic!(format!("Couldn't find {}", cup));
+}
+
+fn reorder_starting_from(cups: &[u8; 9], n:u8) -> [u8; 9] {
+
+    let n_idx = index_of(cups, &n);
+    let mut res = [0u8; 9];
+    for i in 0..9 {
+        res[i] = cups[(n_idx + 1 + i) % cups.len()];
+    }
+    return res;
+
+}
--- a/src/dayX.rs
+++ b/src/dayX.rs
@@ -2,4 +2,12 @@ use super::util;

 pub fn solve() {
    let lines = util::read_file("input/dayX.txt");
+
+
+    let part1 = 0;
+    println!("Day X Part 1: {}", part1);
+
+
+    let part2 = 0;
+    println!("Day X Part 2: {}", part2);
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -13,8 +13,20 @@ mod day8;
 mod day9;
 mod day10;
 mod day11;
+mod day12;
+mod day13;
+mod day14;
+mod day15;
+mod day16;
+mod day17;
+mod day18;
+mod day19;
+mod day20;
+mod day21;
+mod day22;
+mod day23;

-const MAX_DAY: u8 = 11;
+const MAX_DAY: u8 = 23;
 const BENCHMARK_AMOUNT: u32 = 100;

 fn solve(day: u8) {
@@ -30,13 +42,24 @@ fn solve(day: u8) {
        9 => day9::solve(),
        10 => day10::solve(),
        11 => day11::solve(),
+        12 => day12::solve(),
+        13 => day13::solve(),
+        14 => day14::solve(),
+        15 => day15::solve(),
+        16 => day16::solve(),
+        17 => day17::solve(),
+        18 => day18::solve(),
+        19 => day19::solve(),
+        20 => day20::solve(),
+        21 => day21::solve(),
+        22 => day22::solve(),
+        23 => day23::solve(),
        _ => println!("This day is not yet implemented")
    }
 }

 fn main() {

-
    let args: Vec<String> = std::env::args().collect();

    let day_arg_idx = args.iter().position(|a| a == "-d");
@@ -49,8 +72,11 @@ fn main() {

    // This is essentially the warmup for the benchmark:
    run_once(single_day, day, &mut bench_results);
+    let first_run_time = bench_results[0];

    if benchmark {
+        // Ignore the warmup run in the rest of the benchmark:
+        bench_results.clear();
        for _ in 0..BENCHMARK_AMOUNT {
            run_once(single_day, day, &mut bench_results);
        }
@@ -59,6 +85,19 @@ fn main() {
    let avg_runtime: u128 = bench_results.iter().sum::<u128>() / (bench_results.len() as u128);

    println!("Execution took {} μs {}", avg_runtime, if benchmark { "on average" } else { "" });
+    if benchmark {
+        bench_results.sort();
+        println!("Min: {} μs, Max: {} μs, Median: {} μs",
+                 bench_results[0],
+                 bench_results[bench_results.len() - 1],
+                 bench_results[bench_results.len() / 2]
+        );
+        println!("First time took {} μs", first_run_time);
+
+        // for res in bench_results {
+        //     println!("{}", res);
+        // }
+    }
 }

 fn run_once(single_day: bool, day: u8, bench_results: &mut Vec<u128>) {
Author	SHA1	Message	Date
Bas Dado	e2931282dc	[TASK] Solved Day 23 Pt 1	2020-12-29 22:19:21 +01:00
Bas Dado	d48df9336f	[TASK] Solved day 21	2020-12-28 21:33:20 +01:00
Bas Dado	9e6cefba9e	[WIP] Still working on day 20	2020-12-28 19:54:43 +01:00
Bas Dado	423f683374	[TASK] Solved day 22 part 1 (part 2 partly solved)	2020-12-22 10:54:06 +01:00
Bas Dado	acaf136814	[TASK] Solved Day 20 Pt 1	2020-12-21 13:57:35 +01:00
Bas Dado	006eb5f19e	[TASK] Solved day 18 (better late than never)	2020-12-19 20:07:56 +01:00
Bas Dado	ff2a2c5bb3	[TASK] Solved day 19 (haven't solved day 18 yet tho, coming up!)	2020-12-19 10:55:48 +01:00
Bas Dado	9967283916	[TASK[ Finished day 17	2020-12-17 21:45:27 +01:00
Bas Dado	040965a034	[TASK] Solved Day 16	2020-12-17 00:02:19 +01:00
Bas Dado	b118845a5e	[TASK] Solved Day 15	2020-12-16 09:14:38 +01:00
Bas Dado	e80edae003	[TASK] Solved Day 14 (but I think it can be solved faster)	2020-12-14 14:09:58 +01:00
Bas Dado	55a53e14f7	[CLEANUP] Removed some unused Day13 code	2020-12-14 09:09:16 +01:00
Bas Dado	1b1fe127c3	[TASK] Solved day 13	2020-12-14 09:05:46 +01:00
Bas Dado	9684b28a65	[TASK] Finished day 12	2020-12-12 11:16:50 +01:00
Bas Dado	4a8c5580ff	[TASK] Added some padding to the grid to save some time on out-of-bounds checks, but it's still pretty slow	2020-12-11 22:31:05 +01:00