[TASK] Solved day 22 part 1 (part 2 partly solved)

Cargo.lock

@@ -5,9 +5,7 @@ name = "advent-of-code-2020-rust"
 version = "0.1.0"
 dependencies = [
  "lazy_static",
- "rayon",
  "regex",
- "usize_cast",
 ]
 
 [[package]]
@@ -19,147 +17,18 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "autocfg"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "const_fn"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd51eab21ab4fd6a3bf889e2d0958c0a6e3a61ad04260325e919e652a2a62826"
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dca26ee1f8d361640700bde38b2c37d8c22b3ce2d360e1fc1c74ea4b0aa7d775"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9"
-dependencies = [
- "cfg-if",
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1aaa739f95311c2c7887a76863f500026092fb1dce0161dab577e559ef3569d"
-dependencies = [
- "cfg-if",
- "const_fn",
- "crossbeam-utils",
- "lazy_static",
- "memoffset",
- "scopeguard",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02d96d1e189ef58269ebe5b97953da3274d83a93af647c2ddd6f9dab28cedb8d"
-dependencies = [
- "autocfg",
- "cfg-if",
- "lazy_static",
-]
-
-[[package]]
-name = "either"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aca5565f760fb5b220e499d72710ed156fdb74e631659e99377d9ebfbd13ae8"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
-[[package]]
-name = "libc"
-version = "0.2.81"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1482821306169ec4d07f6aca392a4681f66c75c9918aa49641a2595db64053cb"
-
 [[package]]
 name = "memchr"
 version = "2.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525"
 
-[[package]]
-name = "memoffset"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "157b4208e3059a8f9e78d559edc658e13df41410cb3ae03979c83130067fdd87"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "num_cpus"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
-dependencies = [
- "hermit-abi",
- "libc",
-]
-
-[[package]]
-name = "rayon"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b0d8e0819fadc20c74ea8373106ead0600e3a67ef1fe8da56e39b9ae7275674"
-dependencies = [
- "autocfg",
- "crossbeam-deque",
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ab346ac5921dc62ffa9f89b7a773907511cdfa5490c572ae9be1be33e8afa4a"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "lazy_static",
- "num_cpus",
-]
-
 [[package]]
 name = "regex"
 version = "1.4.2"
@@ -178,12 +47,6 @@ version = "0.6.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189"
 
-[[package]]
-name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-
 [[package]]
 name = "thread_local"
 version = "1.0.1"
@@ -192,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"

Cargo.toml

@@ -8,6 +8,4 @@ edition = "2018"
 
 [dependencies]
 regex = "1"
-lazy_static = "1.4.0"
+lazy_static = "1.4.0"
-usize_cast = "1.0.0"
-rayon = "1.5.0"

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

input/day12_example.txt

@@ -0,0 +1,5 @@
+F10
+N3
+F7
+R90
+F11

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

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

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

input/day14_example.txt

@@ -0,0 +1,4 @@
+mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X
+mem[8] = 11
+mem[7] = 101
+mem[8] = 0

input/day15.txt

@@ -0,0 +1 @@
+17,1,3,16,19,0

input/day15_example.txt

@@ -0,0 +1 @@
+0,3,6

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

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

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

input/day17.txt

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

input/day17_example.txt

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

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)

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

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

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

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:
+#.#.#####.
+.#..######
+..#.......
+######....
+####.#..#.
+.#...#.##.
+#.#####.##
+..#.###...
+..#.......
+..#.###...

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

input/day22_example.txt

@@ -0,0 +1,13 @@
+Player 1:
+9
+2
+6
+3
+1
+
+Player 2:
+5
+8
+4
+7
+10

src/day11.rs

@@ -2,27 +2,19 @@ use super::util;
 use crate::day11::GridState::Floor;
 use crate::day11::GridState::FilledSeat;
 use crate::day11::GridState::EmptySeat;
-use rayon::prelude::*;
-use std::time::Instant;
 
 pub fn solve() {
     let lines = util::read_file("input/day11.txt");
 
-    let seats = Seats::parse(&lines);
+    let seats = Seats::parse(&lines, 1);
-
-    let now = Instant::now();
 
     let part1 = solve_part1(&seats);
 
-    println!("Part 1 took: {} μs", now.elapsed().as_micros());
     println!("Day 11 Part 1: {}", part1);
 
-    let now2 = Instant::now();
-
     let visible_chairs = seats.calculate_all_visible_chairs();
     let part2 = solve_part2(&seats, &visible_chairs);
 
-    println!("Part 2 took: {} μs", now2.elapsed().as_micros());
     println!("Day 11 Part 2: {}", part2);
 }
 
@@ -31,38 +23,27 @@ fn solve_part1(seats: &Seats) -> usize {
     let mut last_seats = seats.clone();
     let mut next_seats = seats.clone();
 
-    let mut seat_idxs = Vec::new();
-    for y in 0..seats.height {
-        for x in 0..seats.width {
-            let seat = seats.get(&x, &y);
-            if seat != &Floor {
-                seat_idxs.push((x, y));
-            }
-        }
-    }
     loop {
-        let changes: Vec<(usize, usize, &GridState)> = seat_idxs.par_iter().map(|pos| {
+        let mut changes = false;
-            let x = &pos.0;
+        for y in 1..seats.height-1 {
-            let y = &pos.1;
+            for x in 1..seats.width-1 {
-            let seat = last_seats.get(x, y);
+                let seat = last_seats.get(&x, &y);
-            let occupied = last_seats.count_occupied_neighbors(x, y);
+                if seat != &Floor {
-            if seat == &EmptySeat && occupied == 0 {
+                    let occupied = last_seats.count_occupied_neighbors(&x, &y);
-                return Option::from((pos.0, pos.1, &FilledSeat));
+                    if seat == &EmptySeat && occupied == 0 {
-            } else if seat == &FilledSeat && occupied >= 4 {
+                        changes = true;
-                return Option::from((pos.0, pos.1, &EmptySeat));
+                        next_seats.set(&x, &y, FilledSeat);
-            } else {
+                    } else if seat == &FilledSeat && occupied >= 4 {
-                return Option::None;
+                        next_seats.set(&x, &y, EmptySeat);
+                        changes = true;
+                    }
+                }
             }
-        }).filter(|o| o.is_some()).map(|o| o.unwrap()).collect::<Vec<_>>();
-
-        if changes.is_empty() {
-            break;
-        }
-
-        for change in changes {
-            next_seats.set(&change.0, &change.1, *change.2);
         }
         // next_seats.print();
+        if !changes {
+            break;
+        }
 
         last_seats = next_seats.clone();
     }
@@ -74,11 +55,7 @@ fn solve_part2(seats: &Seats, visible_chairs: &Vec<Option<Vec<(usize, usize)>>>)
     let mut last_seats = seats.clone();
     let mut next_seats = seats.clone();
 
-    let mut calc_times = Vec::new();
-    let mut copy_times = Vec::new();
-
     loop {
-        let calc_start = Instant::now();
         let mut changes = false;
         for y in 0..seats.height {
             for x in 0..seats.width {
@@ -89,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);
                     }
                 }
             }
@@ -99,15 +76,9 @@ fn solve_part2(seats: &Seats, visible_chairs: &Vec<Option<Vec<(usize, usize)>>>)
         if !changes {
             break;
         }
-        calc_times.push(calc_start.elapsed().as_micros());
 
-        let now = Instant::now();
         last_seats = next_seats.clone();
-        copy_times.push(now.elapsed().as_micros());
     }
-
-    println!("Avg calc time: {} μs", calc_times.iter().sum::<u128>() / (calc_times.len() as u128));
-    println!("Avg copy time: {} μs", copy_times.iter().sum::<u128>() / (copy_times.len() as u128));
     return last_seats.grid.iter().filter(|s| s == &&FilledSeat).count();
 }
 
@@ -123,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 height = lines.len() + padding * 2;
-        let width = lines[0].len();
+        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())
             }
         }
 
@@ -199,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 self.is_occupied(&(x - &ONE), &(y - &ONE)) { 1 } else { 0 } +
-            if !x_lower && self.is_occupied(&(x - &ONE), &y) { 1 } else { 0 } +
+            if 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 self.is_occupied(&(x - &ONE), &(y + ONE)) { 1 } else { 0 } +
-            if !y_lower && self.is_occupied(&x, &(y - ONE)) { 1 } else { 0 } +
+            if self.is_occupied(&x, &(y - ONE)) { 1 } else { 0 } +
-            if !y_upper && self.is_occupied(&x, &(y + ONE)) { 1 } else { 0 } +
+            if 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 self.is_occupied(&(x + ONE), &(y - ONE)) { 1 } else { 0 } +
-            if !x_upper && self.is_occupied(&(x + ONE), &y) { 1 } else { 0 } +
+            if 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 }
 
     }
 

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(),
+        }
+    }
+}

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,
+}

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 };
+    }
+}

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;
+
+}

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));
+
+    }
+}

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; }
+    }
+
+}

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())
+        }
+    }
+}

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
+}

src/day20.rs

@@ -0,0 +1,157 @@
+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 edge_matches: 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| { edge_matches.entry(m.clone()).and_modify(|c| *c += 1 ).or_insert(1); })
+    }
+
+    println!("{:?}", edge_matches);
+    let corner_pieces: Vec<u32> = edge_matches.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);
+}
+
+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 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 };
+    }
+}

src/day22.rs

@@ -0,0 +1,110 @@
+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
+        if known_configurations.contains(&(&p1_stack, &p2_stack)) {
+            // Player 1 wins by infinite loop protection:
+            return (1, calculate_score(&p1_stack));
+        }
+        known_configurations.insert((p1_stack.clone(), p2_stack.clone()));
+
+        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();
+
+}

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);
 }

src/main.rs

@@ -13,8 +13,18 @@ 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 day22;
 
-const MAX_DAY: u8 = 11;
+const MAX_DAY: u8 = 22;
 const BENCHMARK_AMOUNT: u32 = 100;
 
 fn solve(day: u8) {
@@ -30,13 +40,22 @@ 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(),
+        22 => day22::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 +68,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 +81,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>) {