[TASK] Attempted to improve the performance of day11 by executing the iterations in parallel...Unfortunately it just got twice as slow...

Cargo.lock

@@ -5,7 +5,9 @@ name = "advent-of-code-2020-rust"
 version = "0.1.0"
 dependencies = [
  "lazy_static",
+ "rayon",
  "regex",
+ "usize_cast",
 ]
 
 [[package]]
@@ -17,18 +19,147 @@ 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"
@@ -47,6 +178,12 @@ 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"
@@ -55,3 +192,9 @@ 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

@@ -9,3 +9,5 @@ edition = "2018"
 [dependencies]
 regex = "1"
 lazy_static = "1.4.0"
+usize_cast = "1.0.0"
+rayon = "1.5.0"

input/day12.txt

@@ -1,795 +0,0 @@
-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

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

input/day13.txt

@@ -1,2 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,567 +0,0 @@
-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

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

input/day15.txt

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

input/day15_example.txt

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

input/day16.txt

@@ -1,262 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

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

input/day17_example.txt

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

input/day18.txt

@@ -1,373 +0,0 @@
-(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

@@ -1,7 +0,0 @@
-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

@@ -1,578 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,107 +0,0 @@
-Tile 2311:
-..##.#..#.
-##..#.....
-#...##..#.
-####.#...#
-##.##.###.
-##...#.###
-.#.#.#..##
-..#....#..
-###...#.#.
-..###..###
-
-Tile 1951:
-#.##...##.
-#.####...#
-.....#..##
-#...######
-.##.#....#
-.###.#####
-###.##.##.
-.###....#.
-..#.#..#.#
-#...##.#..
-
-Tile 1171:
-####...##.
-#..##.#..#
-##.#..#.#.
-.###.####.
-..###.####
-.##....##.
-.#...####.
-#.##.####.
-####..#...
-.....##...
-
-Tile 1427:
-###.##.#..
-.#..#.##..
-.#.##.#..#
-#.#.#.##.#
-....#...##
-...##..##.
-...#.#####
-.#.####.#.
-..#..###.#
-..##.#..#.
-
-Tile 1489:
-##.#.#....
-..##...#..
-.##..##...
-..#...#...
-#####...#.
-#..#.#.#.#
-...#.#.#..
-##.#...##.
-..##.##.##
-###.##.#..
-
-Tile 2473:
-#....####.
-#..#.##...
-#.##..#...
-######.#.#
-.#...#.#.#
-.#########
-.###.#..#.
-########.#
-##...##.#.
-..###.#.#.
-
-Tile 2971:
-..#.#....#
-#...###...
-#.#.###...
-##.##..#..
-.#####..##
-.#..####.#
-#..#.#..#.
-..####.###
-..#.#.###.
-...#.#.#.#
-
-Tile 2729:
-...#.#.#.#
-####.#....
-..#.#.....
-....#..#.#
-.##..##.#.
-.#.####...
-####.#.#..
-##.####...
-##..#.##..
-#.##...##.
-
-Tile 3079:
-#.#.#####.
-.#..######
-..#.......
-######....
-####.#..#.
-.#...#.##.
-#.#####.##
-..#.###...
-..#.......
-..#.###...

input/day22.txt

@@ -1,53 +0,0 @@
-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

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

src/day11.rs

@@ -2,19 +2,27 @@ 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, 1);
+    let seats = Seats::parse(&lines);
+
+    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);
 }
 
@@ -23,28 +31,39 @@ fn solve_part1(seats: &Seats) -> usize {
     let mut last_seats = seats.clone();
     let mut next_seats = seats.clone();
 
-    loop {
+    let mut seat_idxs = Vec::new();
-        let mut changes = false;
+    for y in 0..seats.height {
-        for y in 1..seats.height-1 {
+        for x in 0..seats.width {
-            for x in 1..seats.width-1 {
+            let seat = seats.get(&x, &y);
-                let seat = last_seats.get(&x, &y);
             if seat != &Floor {
-                    let occupied = last_seats.count_occupied_neighbors(&x, &y);
+                seat_idxs.push((x, y));
+            }
+        }
+    }
+    loop {
+        let changes: Vec<(usize, usize, &GridState)> = seat_idxs.par_iter().map(|pos| {
+            let x = &pos.0;
+            let y = &pos.1;
+            let seat = last_seats.get(x, y);
+            let occupied = last_seats.count_occupied_neighbors(x, y);
             if seat == &EmptySeat && occupied == 0 {
-                        changes = true;
+                return Option::from((pos.0, pos.1, &FilledSeat));
-                        next_seats.set(&x, &y, FilledSeat);
             } else if seat == &FilledSeat && occupied >= 4 {
-                        next_seats.set(&x, &y, EmptySeat);
+                return Option::from((pos.0, pos.1, &EmptySeat));
-                        changes = true;
+            } else {
+                return Option::None;
             }
-                }
+        }).filter(|o| o.is_some()).map(|o| o.unwrap()).collect::<Vec<_>>();
-            }
+
-        }
+        if changes.is_empty() {
-        // next_seats.print();
-        if !changes {
             break;
         }
 
+        for change in changes {
+            next_seats.set(&change.0, &change.1, *change.2);
+        }
+        // next_seats.print();
+
         last_seats = next_seats.clone();
     }
     return last_seats.grid.iter().filter(|s| s == &&FilledSeat).count();
@@ -55,7 +74,11 @@ 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 {
@@ -66,8 +89,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 {
-                        changes = true;
                         next_seats.set(&x, &y, EmptySeat);
+                        changes = true;
                     }
                 }
             }
@@ -76,9 +99,15 @@ 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();
 }
 
@@ -94,16 +123,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>, padding: usize) -> Seats {
+    fn parse(lines: &Vec<String>) -> Seats {
 
-        let height = lines.len() + padding * 2;
+        let height = lines.len();
-        let width = lines[0].len() + padding * 2;
+        let width = lines[0].len();
         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 + padding) + (y + padding) * width] = GridState::parse(&line_chars.next().unwrap())
+                grid[x + y * width] = GridState::parse(&line_chars.next().unwrap())
             }
         }
 
@@ -170,15 +199,20 @@ 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 self.is_occupied(&(x - &ONE), &(y - &ONE)) { 1 } else { 0 } +
+            if !x_lower && !y_lower && self.is_occupied(&(x - &ONE), &(y - &ONE)) { 1 } else { 0 } +
-            if self.is_occupied(&(x - &ONE), &y) { 1 } else { 0 } +
+            if !x_lower && self.is_occupied(&(x - &ONE), &y) { 1 } else { 0 } +
-            if self.is_occupied(&(x - &ONE), &(y + ONE)) { 1 } else { 0 } +
+            if !x_lower && !y_upper && self.is_occupied(&(x - &ONE), &(y + ONE)) { 1 } else { 0 } +
-            if self.is_occupied(&x, &(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 + ONE), &(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) { 1 } else { 0 } +
+            if !x_upper && self.is_occupied(&(x + ONE), &y) { 1 } else { 0 } +
-            if self.is_occupied(&(x + ONE), &(y + ONE)) { 1 } else { 0 }
+            if !x_upper && !y_upper && self.is_occupied(&(x + ONE), &(y + ONE)) { 1 } else { 0 }
 
     }
 

src/day12.rs

@@ -1,174 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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

@@ -1,272 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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,12 +2,4 @@ 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,18 +13,8 @@ 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 = 22;
+const MAX_DAY: u8 = 11;
 const BENCHMARK_AMOUNT: u32 = 100;
 
 fn solve(day: u8) {
@@ -40,22 +30,13 @@ 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");
@@ -68,11 +49,8 @@ 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);
         }
@@ -81,19 +59,6 @@ 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>) {