feat: solve day 25

feat: solve day 24
feat: solve day 23 part 2
2022-05-22 20:22:21 +00:00 · 2022-05-22 18:39:45 +00:00 · 2022-05-22 15:22:22 +00:00 · 2022-05-22 14:28:46 +00:00 · 2022-05-22 13:23:01 +00:00 · 2022-05-22 10:38:50 +00:00
24 changed files with 4246 additions and 0 deletions
--- a/18/input.txt
+++ b/18/input.txt
@ -0,0 +1,372 @@
 6 + (3 + 6 + 5 * 4) * (4 + 3) * 8 + 6 + 6
 7 + 6 + (9 + 4 * (8 + 7 * 8 + 2 * 7 * 9) * 9 + 5 + 3) + 6 + (7 + 5 + 7 * 9 + 9) * ((4 + 9 * 3 * 4 * 3) + 6 * 8)
 3 + (6 + 4 * (8 + 4 * 3 + 8) * 7 + 5 + 4) * 3 * 2 + 5 + 4
 2 * 4 + 4 + (5 * 9 + 3 + 9) * 6 * 2
 3 * 7 + 4 + 6 * ((8 * 9 * 2 * 9) + (9 + 3 * 6) + (3 + 4 * 8 + 2) * 2) * 2
 (9 * 2 * 7 * 5) * (6 + 3 * 3 * 3) + 5 + 9
 (7 * 2) + ((7 * 3 * 7 + 2) * 3)
 2 + ((4 * 8) + 6 * (3 + 5) * 4 * (6 * 7) * 4) * 8 + (7 * 5 * (8 * 3 * 8) * 5) + 6 * 2
 (2 * 4 + (4 * 2 * 2 + 3 + 8 * 5)) * (3 * 4 + 6 + 7 * 5) * 5 * 5 + 6 * 7
 4 * 8
 5 * (5 + (3 + 2 + 7 * 6)) + 4
 (8 * 2) * 8 * 9 * 7 + (9 * 6 * 6 + 4) + 2
 2 * (3 * 8 + (3 + 5) + 4) * 7 + 8 + 3
 6 * 2 * 5 * 9 * 4
 (5 + 5 + 5 * 2 + 3 + 8) * 5 * 2 + 9 + (8 + 8)
 5 + 6 + 3 * (2 * (4 + 9 + 7 * 8) * 9 + 4 + 8) * (5 * 7 * 9 * 5 * (3 + 2 * 6 * 4))
 3 + (2 * 4) + 8 * (3 + 5) + 9 * 8
 ((4 * 7 + 5 * 2 * 3 + 9) + 4 + 6 * 9 + 6 + (6 + 9)) * 4
 2 + (2 + (2 * 6 * 3 + 2 * 6)) * 9 * 7 + (7 + 7 + 2) + 5
 7 + 4 * 4 * 4 * 8 * 7
 6 * (5 * (8 * 8 + 7) * (6 + 5 + 6 * 3 * 2) + 4) * 9 * 2 + 7
 (8 + 8 * (6 * 3 * 2 * 8 * 5) * (2 * 3 * 5 + 2 * 6)) + 5 + 4 * (4 * (7 * 9 + 8 * 6) * 7 * 9)
 9 * (2 + 7 + 3 + 7 * 9) + 3 + 6 + 7 + 4
 9 * 9 * (4 + 8 + (9 * 8 + 6 + 2 + 6 + 3) * 4 * 9 + 5)
 6 + 9 + 2 * ((6 + 9 + 5) + 8 + 6 + 5 + 5 + 6) + 7 * 8
 ((3 * 2 * 5 + 3) + 8 + 7 + 9 + 2 * 8) * 9
 7 + 4 + 8 * 4 + 4 + (4 * (7 + 8 + 6 * 6 + 2) + (7 + 9 + 7 + 4) * 9 + 9 * 5)
 8 * 8 * (2 + 9 * 3 * 5) + ((4 * 5 + 3 + 8 * 6 + 3) * 5 + 2 * (6 + 8 + 6) + 4) * 2
 ((3 + 4 * 2 * 9 * 2) + (8 * 3 + 7) * 7 + 6 + (4 * 7) * 5) + ((2 * 8 + 5 + 7 * 8 * 9) + 7 + 6 * 5)
 6 + 4
 2 + (6 * 9 + 8 + 2) * ((7 * 5) + 6 * 9 * 7 * 7) + 3 + 6
 ((6 * 8 * 7 * 2 * 6) * 9 + 6 * (6 * 8) + 9) + 3 + 9
 9 + (8 * 9 * 9) + (4 + 8 * (2 + 9 + 4) + (3 + 9 * 4 * 5 * 8 * 3) * 9 + 2)
 3 * 2 * (3 + (4 + 3 + 3 * 5) * 4 + 3 * 8)
 2 * 5 + ((3 * 9 + 6 + 7) + (2 * 6 * 4 * 2 * 5 * 7)) * 5
 3 + 8 * 9 * ((3 + 4) + 2 + 9 * (4 * 4) + 3) + 3 + (5 + 3 + 5)
 (4 + 4 * 7 * (3 + 4) * 2) * 8 + (4 + 8 * 9 * 9 + 4) + 2
 (3 + 7 + 9 * 6 * (8 * 4 + 6 + 4 + 5 + 7) * (3 + 9)) + 3 + 2 * 4 + 7 + 8
 (3 * 4 * 9) * 2 + 4 + 6 + 2 * ((8 + 2 + 5) + 5)
 4 * ((3 + 9 * 2 + 4) + 6 * 9 + 6 * 5 * 3) * 9 + 7 * (9 * 9)
 (8 * 4 + 3) + 7 * 6 * 4 * 3 * ((6 + 5) * 6 * 2 * 6)
 5 * (7 * 5 * (7 + 2 + 6 * 5 + 8) + 3 * 2) * 2 + 3
 7 * 9 + (4 + 8 + 7) * 3 * (9 + (8 * 2 * 7 + 8 * 7 * 6) + 3 * 8 * 9)
 8 * 3 + (2 + 9 + 8 * 5) * 8 * 2 + (4 * 8 * 7 + 5)
 5 + 4 + (2 + 3) * 9 + (3 * 7 * 9 + 3) * 4
 4 + (8 * 8 * 5 * 4)
 9 * 9 + (5 + (9 * 5 * 2 * 5)) * 9
 (3 * (6 * 7 * 8) + 4 * 4 + (2 * 2 * 9 * 4)) * 7 * 4
 4 + (8 * (7 * 6 * 2 * 9) + 5 * (3 * 7 + 6 * 7) * 7 * 8) + (2 + 2 * 4 + (8 + 5 + 5 * 3 + 2 + 5) + (2 * 9))
 2 * 7 * (3 * 8 + 2 * 7) * 2 + 8 + 8
 3 + (2 * 8 + 2) + 9
 ((6 * 3 * 4 * 9 * 7 * 4) + 2 + (7 * 6 * 3 + 6) * 9 + (5 + 3 + 5 + 7)) + 6 + 8 + 3
 4 * 6 + (9 + 6 * 4 * 9 + (5 + 3 + 5) + 4) * 2 + 8 + 9
 (7 + 2 * (4 * 5 + 5 * 3) * 8) * 4 * 2 + 7 + ((6 + 8 * 8 + 2 * 4 + 5) + (9 + 3))
 6 + 6 + 9 + 9 + (4 + (2 + 4 + 8 + 3 + 3) * 8 + 3 * 2) * 3
 5 * (4 + 4 + 4 * 7 * 4) + 7 * 4
 5 * ((5 * 8 * 9 + 2 + 8) * 6 + (5 + 3) * 4 + 8 + 3) * 8
 5 + (2 * 7 + 2 * 6 * 3) + (2 * 3 * (3 + 6 * 9)) * 4
 ((4 + 6 * 3) + 6) * 6
 3 * 4 + (9 + (4 * 9 * 9 + 6 * 2) + 4 * 9 + 2) * 3
 7 * 9 * 9 + 7 * 3 + 9
 6 + 2 * 4 + ((9 + 5) + 4)
 (7 * 2 * 6) * 6 + (5 * 3) + ((7 * 4) + (2 * 8 + 6 + 9) * (7 + 4) + 8 + (2 + 7 + 6 * 3 * 7) * 3) * 3 + 2
 7 * (7 * 3) * 7 + (6 * 2 + (8 + 6 + 5 + 8 * 4 + 9) + 4 * 2)
 (6 + (9 * 4 * 9 + 9 * 7)) * (4 * 5 + 6 + 2 + 6 + 9) * 6
 ((6 * 7 * 3) * 6 * 9) + (8 * 4 * 8) * 3 * 9 * 6
 5 * 6 * 6
 9 + (3 * 8 * (5 + 9 * 4)) * (5 * 2 + 4 * 6 * 3)
 (8 * 5 * 2) * (8 * 3) + 4 * 6
 ((8 * 8 + 3 * 5 + 6) * 8 * 5) * 5
 (3 + 5 * 7 * (2 + 4 + 3) + (5 + 4 + 7 * 3 + 9) + 6) * 3
 7 + 2 * 7 + ((6 * 9) + 2 + 9 * 2 * 5) + 2 + 7
 5 * (5 + 8 * 3 + 9) * 4 * 9 * 2
 (9 * 3 * 3 * 9 + 5 * 9) + 8 * ((2 * 7 + 5 * 3) + 8 * 9 + (6 * 6 + 9) * 6) + (8 + 6 * 7 * 9)
 8 * ((2 * 4 + 6 * 6 + 9) + 7 * 4) * 6 + 5
 3 * 9 * 8 + (4 + (2 * 7 * 6) * 9) + 7 + 9
 2 * (6 + 5 * 7 * (8 + 8 * 9 + 9 + 3 * 8) + (6 * 6) * 4) + 5 * 7 + 3
 6 + 2 + (3 + 7 + 8 * 2)
 (9 + 2 + 6 * (9 * 9 * 7 * 5 * 6 + 6) + (2 * 2 * 5 * 7)) + 3 + 4
 2 + 8 * 5 + (5 + 4 + 7 * 3 * 6 * 9) * 5 * 9
 (4 * (2 * 6 * 8) * 9 * 9 + 6) * 8 * 9 + 6 * 4 + 5
 4 * 4 * 4 * 4 + 5
 (2 * 2 + 3 + 2 + 7 + 6) * (4 * 7 + (2 * 5))
 3 * 7 + 8 + 9 + 7 + 9
 ((2 + 6) + 4) * (8 * 5 * 3 + (5 * 4 * 3 * 9) * (4 * 9 * 2 + 2 + 5 + 9) + 8) + 2
 5 + 6 * (3 + (3 + 8 + 5) + 7 + 6 + 5) + 9 + 9
 (9 + 3) + 3
 9 * (3 + 3 * (8 * 7) * 8) * (6 * 8) + 4 + ((4 * 2 + 6 + 5) + 8)
 (4 * (6 * 8 + 3 * 3 * 9 * 6) + 6) * 5 * 3
 6 + 4 + 4
 (5 * 9 + (6 + 2 + 6) + 5 + 2 + 9) + (6 * 8) + (2 * 5)
 (4 * (4 * 3 * 2 * 4) + 5 + 6) + 4 * 9 * (4 + (9 + 7) * 8) * 6 * 9
 4 * 3 + 5 * 2 * (2 * 8 * (6 + 8 * 7)) + 6
 7 + 4 * 8 * 4 * (6 * 5 * 2 + 8 * 7)
 8 * 2 * (7 + 6 + (4 * 7 + 8 * 5 * 2) + (3 * 7) * 8) * 8 * 4
 (7 * 9 + 4 * 2 + 6 * 7) + (8 + 7) * 9 * 9 * 6
 (6 * 8 + 5 + 9 * 2 * 3) * 4 * 4 * ((7 + 7) * 8 * 3 + (9 * 2 + 7) * 2 + 3)
 3 * ((2 + 8 + 9 * 4 * 5 * 4) * 5 + 8 + 8) + 5 + 5 * 2
 4 * 4 * (6 * 4 * (5 + 2 + 9 + 5 * 8)) * 6
 9 + 4 + (7 * 3 * 4 + 9) + (8 + 2 * 9 * (2 + 9 * 2 * 7 + 7)) + (5 + 4 + (9 + 8) * 4 + 7) * 6
 (3 + 5 + 4 + (2 * 3 + 7 + 2 + 2 + 5)) * (6 + 3 * 5 + (9 + 2 + 4 + 5)) + 7 * 8 * 6
 4 + 3 + ((2 + 9 * 3 * 5 + 9 + 7) + (3 + 3 * 8 + 2 + 6) * 4 + 5) * 8 + 6 + 2
 4 * 9
 5 + (2 + (5 * 6 * 3 + 9) * (8 + 7) + 9 + 4) * 4 + 2 + 3
 (6 + 6) + 8 + 4 * (3 * 9 * 7 * 9 * 8) * 4 * 8
 (5 + 7 + 8 + 5 * 4) + 4 * 6 + (2 * 4 + 8 + 9 + 2)
 (9 + 2 * (2 + 3) + 5 * 3) * 2
 7 + 9 + 3 + 3 + (4 * 9 + (6 * 5 + 8 * 9) + 7 + 4) * 4
 6 + (2 * (5 + 8 * 3 + 5 + 7 * 2) * 8) * ((2 + 9) * 6)
 7 * (3 + 2 + (9 + 9 + 7 + 5 * 7 * 9) + 4)
 (5 + 6) + 8 * 5 * 6
 8 + (2 + 7 + 4 + 6 + (5 * 7 + 6 + 2 * 5 * 6)) * 3 * 2
 (5 * 4 * 4) * ((8 * 3) + 7 * 6 * (7 * 6 * 3 + 8)) * 5 + (5 * 9 + 2 * (3 + 6 + 9 * 5 * 9 + 2) + 2 + 6)
 3 + 9 * 3 + 7 + 6
 ((9 * 7 + 7) * 2 + 8) * 6
 (7 + 8 + (3 + 9) + 7 * 8 + 8) + 6
 (4 + 5 + 5 + 3 * 9) * 7 + 9 * 7 + 8 * 5
 8 * 5 * (8 * 6 * 2 + 4 * 3)
 2 + 2 * (6 + (4 + 5 * 7)) + (9 + (4 + 5 * 8 * 2) * 3 + 2)
 3 + 6 * ((9 + 9 * 7 * 5) + 7 * 5 * 8 * 4 + 6) * 3 + 2
 8 + ((5 * 5 + 3) + 9) + 4 + 8
 8 + (9 + (2 + 4 + 3 + 4) + (8 * 5 + 9 + 4)) * (4 * (3 * 7)) + 3 * 3
 9 + 4 + ((5 + 9) + 2) * 6 + ((3 + 9 + 7) * 3 + 2 * 6 + 9 * (7 + 9 + 3 + 3))
 6 * (8 + 5 * 3 * 8 + 3 * 2) * 5
 8 + 5 + ((7 + 2 * 3 + 7) * (9 * 5) * 3 + 2) * 3
 9 + 6 * 8 * ((4 * 5 * 4 * 8 + 8) + (9 + 9 * 7 + 6 * 5) + 6 * 6) * 2 + 3
 4 + 8 + (6 + 5 * 4 * 2 + 2 * 5) + ((2 * 9 + 8 + 7) + (4 * 5) + 6)
 ((9 * 5 * 7 + 4 * 7) + (7 * 4 + 2 + 2) + 8 * 9 * 7 * 6) * (9 * (5 * 4 * 4 + 3)) + 8 * (5 + (5 + 8 + 7) * 4 * (9 + 8 + 6) * 3) * 2 * 6
 ((3 + 6 + 6 + 4 + 5 * 6) + 5 * (5 * 7 + 9 * 4) + (4 + 2 * 6)) + 3 + (8 + 4 + 5 + 4 * 4 * 8) + (7 * 3 * 4)
 6 + (3 * 3 + 8 + 2) + ((6 + 7 * 3) + 9 + 7 * 3 * 4 * 4) * 6 * 6
 7 + (6 * 4 * 3 + 7 + 8 * 7) * 3 + 8
 8 * 9 * 6 + 9 * 3 * (8 * (8 * 5 + 5) + 4 * (5 + 5) + (9 + 2 + 2 * 5 + 3 + 5))
 9 + 2 * 2 + (4 * 2) + 7
 3 + 3 * (3 + 2 * 2 + 3) + (9 + 6 + (6 + 3 + 9) * 6 * 4 * (3 + 4 * 8 * 7 + 9 + 5)) + 9
 ((2 * 8 + 8 * 4 * 3) + 4 + 7 + (5 * 5 + 8 + 6)) * 6 + 4 * ((4 * 3 * 8 + 2 * 9) * 4 * 8)
 (4 + 9 + (3 * 5 * 5)) + 4 + (3 * 4 + 4 + 2 + 6) + 7 * 5 + 8
 (2 * (2 + 3 + 2) + (3 * 8 + 6)) * 9 * 2 * 9 * 9 + 9
 5 * (9 + 4) * 4 + (3 + 7 + 9) + 5
 4 * 5 + (7 * 6 + 7 + 5) * (6 + 2) + 7 * 4
 3 * 6 + 3 + (6 + 7 * 2 * 4) + (9 + (7 + 8 + 7) * 6 * 9 + 6 * (6 * 8 * 8 + 5)) + 2
 5 * 2 + ((9 + 7 * 2) * (9 + 2 + 3 * 2) * 7)
 ((4 + 8 + 2 + 3 + 6 * 3) * 8 + (7 * 9 * 5 + 3 * 2) * (7 * 7 * 9 * 2 * 5) * 3) + 8
 9 * 3 * (6 * 2 * 6 * 4 * (3 * 9) + 2) + 4
 2 * (6 * 9 + (9 * 2)) * 4
 9 + 7 + 7 * 7 * (7 + (9 * 9 * 2 + 4 + 9) * (3 + 4 + 2 + 9) + 6)
 4 * 6 + (3 * (2 * 5 + 4 * 3 + 4) + 6 + (5 + 9 * 7) * 9 + 3) * (3 * 3 * 7 * 7) * 8 + (5 * 6 + 4)
 4 + 7
 ((7 + 5 * 8 + 6 * 3 * 9) * 3 + (5 * 9 * 3 * 2)) + (5 * 6 * 4 * 2) * 7 * 4 + 5 * 6
 (2 + 9 + 2 * 7) + 6 + 3 + 9 + 7
 ((6 * 5 + 2) + 4 * 7 + 4 * (7 * 4 * 2 + 4) * 7) * 3 + 4
 5 + (2 * 3 + (9 * 8 * 9)) + 7 * (6 + 7 + 2)
 4 * 5 * 8 + 6 * ((4 * 7) * 8 * 8 + 7 * 8 + 2)
 8 + ((8 * 2 * 6) * 9 * (9 + 2 + 9 + 4 * 3 * 7) + 5) * 2 * 8 + 8
 ((8 + 4 * 2 + 4) * 5 * 4 + 4 + 8 + 5) * 4 * 6 + 3 + 4 * 4
 6 + 7 * 6 + (6 + 6 + 2)
 ((4 * 9 * 9 + 8) * 6 * 9 + 6) + 2 + 8 * 8 * ((4 * 9 + 6 * 7 + 5) * 4 * 7) * 7
 6 + 5 + (8 + (2 * 8 * 6 * 3) * 4) + (8 + 2) + 2
 (9 * 6) + 5 * 2 * (8 + 5 + 6 + 7) * 4
 9 + (8 * (2 * 4) + 6) * 8 * 4
 9 + 6 + (3 + 2 * 8)
 3 + 9 * 2 + 7 + 4
 ((7 * 9 + 3 + 3) + 5 + (4 * 7 + 9 + 4 + 2)) * 3 + ((9 * 6 * 8 + 5 + 7) + 5 + (4 + 8) + 2 * 4) + 3 * 5
 6 * (9 + (4 * 7 + 9 * 7 * 6 + 9) + 6 + (4 + 7 + 3 * 4 * 6) + 4 + (5 + 2 * 5)) + ((8 + 7 * 3 + 6 * 4 * 7) * 3) + 5 + 9
 ((7 + 5) + 9 + 8 * 5) * 6 + 3 * 7 + 2 * 3
 (9 + (5 + 8 * 9) * 9) + 3 + 6
 9 + 7 * 5 * 8 * (2 + 4)
 6 + 3 * 7 + (3 * 5 + 8 * 7 * (4 * 8 * 5 + 9 * 6 * 4)) * 3
 5 * (4 * 2 * 5 + 6 * 7 * (3 * 9 * 9 + 4 + 2)) + 9
 (5 * 7 + (8 * 4 * 4 * 4 + 5) + (9 + 9) * 5 * (3 + 6 + 7 * 9 + 6)) * 4 + 6 + 4 + ((7 * 4 + 7 + 2 + 7 + 2) * 5)
 (4 * 3 + 5) + 2
 (4 * 4 * (9 * 7)) + (4 * 5 * (3 + 9 * 3 * 2)) * (5 * 7 * 4 * 6)
 2 + 5 * (7 + 2 + 8 + (2 * 9) + 7 + 7) + 2 + 6
 ((9 * 5 * 3 + 7 + 7 * 8) + (6 * 3 + 4 * 8) + 4 * 9 + 9) + 9
 8 + 2 * (9 + (7 * 7 * 3) + 2) + (6 + 5 * (3 + 6 * 9) * 6 + 3)
 ((4 + 8 * 6 * 9 * 2 + 3) + 8 * (7 * 7 * 8 * 6) + 9) * (2 + 6 * 9) + 6 + 4
 6 * 5 + 8 * 7 * (3 + 4 * 7)
 7 * 5 * (5 * 7 + (2 * 7 * 6) + (6 * 3) * 9 + (4 * 7 * 6 + 7 * 7 * 3))
 8 + 7 * 3 + (4 + 6 * (4 * 4 + 9 * 7) * 6 + 8 * 2) * 8 * (8 * 3 + 3 + 6)
 2 + 6 + ((6 + 2 * 3 + 2 + 2 + 6) + 3 + 5 + 7)
 ((9 * 7) + 8 * (9 * 3 * 9 + 8) * 2 + 7 * (6 + 7 + 4 + 6 * 3)) + 7 * 4 + 7
 5 + ((8 + 6) * 7 * 9 + (4 * 5 + 5) * (5 + 3) * 7) + 3
 4 + ((5 + 4 * 5) + 2 * 6 + 5)
 6 + 6 * 8 + (3 * 8 * 2 * (5 + 3)) + 6 + ((3 * 7) + 9 + 7 + 7 + 6 * 7)
 (2 * (4 * 7) + 6 + 8 * 3 + 7) + 8 * 6 * (3 + (3 + 4) * 2 * 3 * (4 * 5 * 2 * 2 * 6)) * 8 * 4
 6 + (8 * 3 + (3 + 9 * 6)) + 2 * 4
 3 * (2 * 9 * 3 + 3) * 5 * 6
 6 * 5 * 3 * 3 * (6 + 7 + 9 + 8)
 9 + 2 * 8 * 6 + ((9 * 9) + (3 * 4 + 4 + 4 * 9 * 7) + 5 + 4 + 9 + 9)
 3 + 9 * 5 * 8 * 5
 5 + 3 * 7 + 9
 9 * ((4 + 4 * 6 + 5) + 3) * (4 + 3)
 (3 * 6 * (8 * 6 * 5) + 2 * 3 + 4) + 6 + 8
 6 + (4 * 8) * 3 + 5 + 2
 2 + (2 * (7 + 6) * (5 + 3 + 2) * 2 + (7 * 9)) * ((5 + 9 + 2 * 8 + 8) + 9 + 8) + 9 + 6
 ((5 * 8 * 4) * 6) + 4 * 4
 6 * 2 * (3 + 4 + 3) * (5 * 4 * 7) * (2 + 4 * 2 + 8)
 6 + 9 * (2 * 7 + (4 * 5 + 7 * 6 + 7 + 8) + 4 + 5)
 ((4 + 6 * 2 * 4) + 2 + 4 * 3) * 9 * 5 * 9
 6 + (3 + (5 + 4 * 2 * 3) + 6) + ((8 + 4 * 8 * 5 * 4 * 4) + 5 * (6 * 6 * 9 * 9) * 3 + 3)
 7 * 8 * (7 + 8 * 2 + 6) * 9
 5 + 3 + 4
 4 + (3 * 6)
 9 * (2 * 6 * 2 + 4 * 5 + (2 + 4 + 6 + 3 * 4 * 5)) * 4 * (8 * 7 * 6)
 6 * (9 * 5 * 9 * 4 + 4)
 (8 * 7 + 8 * 9 + 2) + 4
 6 + (7 * 6 + 8 + 2 * 3 * 8) * 8 + 4 * 2
 ((4 * 8 * 7 + 8) * 9) + (9 + 5) + 4 + 2
 4 + 9 + (5 + 3) + 4 * (9 * (4 * 7 * 5 * 2) * 8) * 3
 5 + 3 * 5 + 6 * 7 + (2 + 7 + (7 + 7 + 9 + 2 * 4 * 6) * 6 * 8 * 8)
 (6 * 4 * 8) * 9 + 7 + 2
 3 * (5 + 5 + 2 + 6 + 3) + 5
 ((2 + 6) + 3) * 7 + 3 * 8 + 2 * (7 + 4 * 4)
 4 * 6 * 8 + (7 * 2 * (5 * 7) * 3 * (2 * 4 + 6 * 4 * 2)) + 2 + 9
 7 + (9 * 4 * 5 * 8) * (4 * 2 + 7 * 2 * 3 * 7) * 3 * 2 * 9
 4 + 6 * 8 * 4 * (2 * 8) + 4
 4 * (8 + (9 + 3) * 4) + 2
 (6 + 7 * 5 + (8 * 4 * 5 + 7 + 8 * 8) + 9) + (4 + (6 * 8 * 6 * 3 + 9) + 4 + 2) + ((9 + 4 + 8 * 7 * 9 + 2) * 2 + 2 * 2 * (2 * 6 + 9)) + 6
 8 + ((5 * 5 + 3 + 2 + 5 * 6) * 6 * (2 + 9 + 8) + 5 + (7 + 6 + 4) + 9)
 (4 * 5 * 9 + 8 + 8 * 5) * 2 * (7 * 9 * 3 + 3) + (2 + 5 * 5 * 3 + 4) + 5 + 7
 (2 + 8 + (5 + 7 + 2 * 9)) * ((8 + 6 + 8 * 2 * 3 + 4) * 3) * 2 * 9
 ((2 + 7 + 6) + 2 * (3 + 6 * 6 * 5 * 2 * 7) * 3 + 8) + 3 + 7 * 6
 5 * 5 + 7 + 3 + 6 * 2
 4 + 9 * (9 + 6 + 6) * 7 * 9 * 8
 ((8 + 5 * 8 * 4) * 5) * (8 * 7 * (4 + 5 + 4 + 3 * 3))
 (9 * (8 * 9 + 9 * 6 + 5 * 8) + 3 * 9 * (5 + 6 + 6 * 4 * 4 * 6)) + 4 * 6 + 8
 6 + (9 * 8 * (8 * 3 * 3 * 7))
 (7 + 7 + 6 + 8 * 3 + 9) * 4 + 9
 7 + 2 + 3 + (8 + 5 + (7 * 7 + 8) * 9 + 7) * (2 + 5 * (4 * 8 + 2 * 5 * 7) * 3 * 9)
 ((3 + 7 + 4 + 9) + 5 + 6 * 3 + 3 * 8) * 2 * ((9 + 5 * 9 * 5) * 3 + (3 * 5 * 7 * 2)) * 9 * 5
 6 + 4 * 9 + (3 + (5 * 3 + 5) * (3 * 8 * 2 * 5)) + (4 + 9 * 4 * 8 * 7 * 4) + 2
 9 + (6 * 8 * 4 * (7 + 4 * 5 * 3 + 5 * 5) + (2 * 7 * 7 * 8))
 (8 + (9 + 8 * 6 + 2) * 7 * (6 + 2 * 6 + 6 + 4 + 7) * 9) * 5 + 3
 4 * 4 * (2 + 8 + (4 + 5 * 4)) * (6 * (2 * 3 + 7) * 7 + 9 + 8) + 3 * 3
 4 * ((9 + 7) * (7 + 2 + 5 + 2 * 4 * 2) * (3 * 7 * 6 + 5 + 9 + 2) * (6 + 9 * 2 * 5 * 8 + 6) + 5 + 8)
 (6 * 5 + 9 + 6) + 2
 2 + 2 * 5 * (3 * 9 + 2 * (6 * 5)) * 8 + (7 + 6)
 2 + (2 + 5 * 9 + (5 + 3 + 8 * 2 + 2) * 4) * (8 * 2 * 2 + 3 + 5 + 8) * 4 + 3
 4 * 9 + (7 * 6 + 2 * (6 + 2 + 9) + 2 * 3)
 (5 * 2) * (4 + (9 * 9 + 9) * 9 + 6 + 6) * (6 * 8 * 7 + 7) + 9 + 3 + 2
 (4 + 2 * 2 * 8 + (3 + 7) * 7) * 8 * 9
 (3 + (8 * 2 + 6) + 5) * 9
 2 + 2 * 4 + (7 + 3 * 9) * 5 * 6
 7 + (4 + 8 * (3 * 7 * 3 + 9) * 9) + 2 * (4 + 8) + 5
 2 * 5 + (4 * 9) * 7 + 5
 7 * 3 * (8 + 2 * (9 * 6) * 8 + 6 * 9) * 9
 9 * (9 + 6 * 2 * (9 + 4 + 8) + 4 * (5 * 8 * 4 + 6 * 6 * 9))
 3 + 7 + ((9 * 6 + 2 * 9 + 6) + 3 + 2)
 (3 + (7 + 4 * 3 + 6 + 7) + (5 * 3) * 8 + 7 + 5) * 2
 (8 * 5) * 8 * 3
 9 * 2 + 9 * 9 * ((3 + 8 + 6 + 5) + 5 + 2 * 2) * 2
 (5 * 4 + (7 * 8 * 2 * 5 * 5 + 2) * 3) * 2 * 7 * (7 * (4 * 8 + 8 + 4 * 6))
 7 + 3 * (8 + 7 + 2 + 4 + (2 * 7 + 3 + 9) * 5)
 4 + 5 + 4 + 5
 8 + 6 * (3 + 8 * 2 * 7 * 9 + 4) + 8
 (9 * 3 * 9 * (3 + 2 + 7 + 5)) + 4
 4 + 4 + (4 * 4) + 3
 6 + 3 * (3 + 3) + 7 * 2 + (8 * 8 + 7 + 8 + 4 * 4)
 4 + 9 * 6 + (2 * 9) * 3 + 6
 4 + 8 + 8 + 2 * ((2 * 7 * 7 + 8 + 4 * 3) * 3 + 8 * 9 * 4)
 (2 * 6 + 7 + (2 * 4 * 5 * 2 * 6) + 7 + (6 * 3 + 3 + 7 * 8)) * 8 + 3 * 8
 3 * 7 * 3 * 5
 ((4 * 9 * 5 + 3 + 4) * 4) * 7 + 3 + 5
 9 * (2 + 5) + 2
 3 * 3 * (8 * 7 + (2 * 9 + 4 + 2 * 9 * 6) + 9) * 2 + 5 + (5 * 8)
 7 + ((3 + 2) * 5 + 6 * 3 + 4 + 5) + (4 * 5 * 9 * 7) + 4
 4 + 4 + 7 + 7 * (3 * 9 + 2 + 4 + 2 * 6) + (6 + 8 * 6 + 9)
 4 * 2 * (4 * 3 * (7 + 2 * 6)) * (6 * (2 + 5 + 7) + 8) + 2
 (3 + 7) * (9 * 7 + 8 + 2) * (8 * 9 + (7 * 7 + 6 * 2 * 6) + (7 + 7 * 6)) + 9 * 7 + 2
 5 + 9 * ((9 * 2 + 5 + 8) + 7 * 7 + 5) + ((3 + 2 * 8 + 8 * 6 + 8) + 4 * 2 * 3 + 9) + (3 * 2 + (6 * 3 + 3 + 6 * 5 * 7) + (2 * 3 * 5 * 9))
 (8 * 9 + 9 + 3 + 3 * 6) * 8 * 8 * 4
 (3 + 4 + 6) + 8 + 4
 (4 + 2 + (6 + 2 + 4)) + 7 + 2
 (3 * 3 + 5 + 5 * 2) + 9 * ((5 * 9) + (9 + 7 + 2 * 9 + 4 * 9) + 3) * ((3 * 2 + 3 * 7 * 6) * (7 * 3 * 4 * 6 + 3)) + 6
 2 * (2 + 9 * 7) + 2 * 8 * 4 * 7
 2 + 6 * (2 * 9 + (4 + 2 + 4 * 5 + 6 + 6) + (5 * 5 * 8) + (8 + 3 + 7 * 8)) * 5 + 9
 (8 + 3 + (6 + 7 + 4 * 9 * 9 + 3)) * 8 * 2 + (5 * 6 + 6 + 6 * 5 + 4)
 (5 * 5 + 2 * 8 * 5) + (8 * 5 * (9 * 3 * 8 * 9)) * 6 + 5 + 4 + 4
 8 + 4 + (2 * 2 * (8 + 2 * 8 + 2 * 9)) + 6 + 3
 3 * 9 * (8 + (7 + 3 + 4 + 5 * 7) + (7 * 5 + 9)) * ((6 * 7 * 6 + 8 + 5) * 6 + (7 + 4) * 5 + (6 + 6 + 3 + 8 + 5) + 2) + ((2 * 7 + 9 * 5 + 3) * (8 * 6 * 2 * 3) + 6 * 9 + 4 + 5) + (6 * 5)
 4 + 4 * 2 + (9 + 3 * (5 * 6 * 4 * 5 + 4))
 6 + 2 * 6 + 7 + 9 * (8 * 4)
 (3 + (5 + 4 * 4 + 8 + 4 + 5) + 8 + 8 + 3 * 8) + 9
 3 * (7 + 4 * (7 + 2 + 6)) * 5
 6 * (5 * 3 * (7 * 3 * 7 + 9 * 5 * 8))
 4 + 7 * 6 + 5 + 6 * 7
 (7 + 9 * (4 * 3 + 2 + 3 * 4 * 6) * 2) * 6 * (5 + 8)
 3 + ((9 * 6 + 6 * 4) + (9 * 9 + 9 + 7 * 3) + 3 * 8) * 7
 (9 * 2 + 2) * (3 + 9 * 3 * 5 * 7)
 5 + 2 + 9 + (6 * (6 + 4 * 4 + 9) + (8 * 4 + 5 * 3 * 9)) + 9 * 5
 8 + (4 + 9 * (7 + 3 * 6 * 5 + 9 + 7) + (3 * 6)) + 5 * 6 + 6
 (7 * (8 + 3 * 3 + 7)) * 9 * (6 + 9) + 3
 5 * ((6 + 7 + 9 + 3 * 2 + 3) + (3 + 5 * 5 + 3 + 9)) + 3 * 7 + 6 + (7 + 4 + (3 * 3) * 5)
 8 + 6 + ((9 + 8 + 3 * 6 * 9) * 3) * 8 + 7 * 9
 7 + (8 + 3 * 6 * 8 * 8 * 3) * 5 * ((3 * 6 * 2 * 7 * 7 + 4) * 5)
 (2 + 2 * (3 + 6) * (8 + 5) + (8 * 6 + 7) * 9) + 6 + 8 * 9
 7 + 7 + (4 + 2 + 4 + 6 * 5 + (8 * 6)) * 9
 7 * 3 + 7 + ((9 + 7) + 6 * (5 + 9 * 8 + 6 + 5 * 4) * 8 * 3 + 3)
 (2 + (2 + 9 + 2)) + 2 + 8
 2 + 2 * (5 * (8 * 4 * 7 + 3 * 5) + 6) * ((9 + 3 * 2 + 5 + 8) * 2 * 9 + 2) * (3 + 9 + 4 * 5)
 7 * 8 * 2 * 8 * 9 + (4 + (5 * 6 * 8 * 9 + 7))
 6 + 2 + 7 * (6 + 7 + 6 * 8 + 9) * 3
 6 + 6 * 7 * (4 * 9 * 9 + 7 + 4 + 9) + 9
 (9 * 9 + 6 * 6 + 3) * 3 * 2 + (3 * 8 + 8 + 4)
 9 + 6 + (9 + 3 + (7 + 5 + 2 + 3))
 5 * 4 + (2 + 2)
 ((7 + 7 * 6 + 2) + 7) + 8 * 7
 6 + (5 * 2) * 9 + 8 + 7 + 8
 9 * 8 + 3 * (4 + 8 + 8 + 5 + 9)
 4 * (2 * 8 + 8 + (5 + 5 * 3 * 5 + 2) + 9 * (8 * 6 + 2 + 2)) + 9 * (6 + 6 * 3 + 8) * 4 + 7
 (3 * 6 + (4 * 9 * 2 * 4 * 8)) + (3 * 5 + 7) + ((9 * 5 + 5 * 2) + 9 + 8 * 7 + 3)
 5 + (3 + 9 + 6 + 2 + (6 + 4 * 2))
 (9 * 5 * (9 * 9) + 8 * 7) + 2 * 7 * 3 + 3
 (9 * 5 + 6 * 7 + 4) * ((3 * 2 * 9 * 4 + 4 + 6) + 2 * 4 + 4 + 9 * 7) * 2 + (8 + 8 * 6 * 8)
 6 + ((5 * 9) * 4 * 5 + (4 * 3 * 7) * (5 + 3 * 3 * 8 + 4 * 4)) + (5 + (6 + 3) * 2 + 8 * 2 + 3) + 3 * 3
 8 + (3 * 8 + 5 + 6 + (3 + 4) + 8) * 2
 9 + 2
 (8 + 2) * 2 * 2 + ((9 * 9 * 4 * 5 * 5 * 3) * 2) + (4 * 3 * 8 + 9 + (8 * 3 * 7 + 4 * 8 * 5))
 6 * 7 + (8 * 5 * 8 * 7 + 7) * 9 + 3 * 7
 3 * 5 * 7 + 8
 (3 + 2 + (8 + 9 * 9 + 6 * 8 + 6) * 3 * 6 + 6) + 4
 3 + 8 + 4 * (4 + 7) * (5 + (3 + 9 + 6) * 7)
 ((4 + 5 * 8 * 5) * 8 * 5) * (2 * 4 * 9 * 4) * 6
 (8 + 3 * 5) * 2 + 2 * 4 * 8 * 6
 8 * 7 * (4 * 7 + (4 * 3 * 4 + 3 * 7) + 2 * (6 * 6 + 6 + 4 + 7 + 2))
 6 + 9 * 5 + 4
 5 * 6 * 8 * ((6 + 9 * 2 * 8 + 5 + 8) + 3 + 6)
 4 * ((4 + 7 * 9 + 9 + 3) * (2 * 4) * 6 + (5 + 9 + 7) + 5) * (8 + 2 + 8 * 5 + (6 + 7 * 7 * 6)) * 2 + (7 * 8)
 (7 * 3 + 4 * (9 + 2 + 6 + 6 * 4 + 2) * 4) * 6 * 2 * 2
 3 * (4 * 8 * 3 + 8 * 6 * 2)
 (3 * 3 + 8 * 4 * 4 + (6 + 3)) * 2 * 7 + 5 + 2 * 4
 9 * 3 * (4 * 7 * 9 * (2 * 4 + 9 * 2) * 2) * 7
 5 + (4 * (6 + 5 * 9 + 6 * 7 * 3) + (7 + 2 + 2 * 9 + 2 + 2) * 3) * 4 * 6 + 2
 7 * (6 * 6 * 7 * 2 + 8 + 8) + 7 + 8 + 7 * (9 + 3 + 4 * 4 + 4 * 8)
 8 + 2 * (4 + (2 * 3 * 8 * 4 * 3))
 6 * (6 * 4 + (5 * 7 * 8 * 2 + 4 * 9) * 2) * 9 + 3 + (3 + 7 * 5 + 3)
 3 * 7 * 5
 7 + (2 * 5 + 5)
 6 * (5 * 9 + 5) * (8 + 7) * ((8 * 8 + 4 + 5) * (2 * 2 * 7 + 4 + 2) + 5) * 3 * 3
 4 * 2 * 2 + ((4 * 7 * 8 + 9 + 2) + 6 * 4 + 3) * (4 + 3 + 3 * 9 * (8 + 6 * 8 + 3 + 9) * 3) * 8
 8 * 9 * 8 + (9 * 7 * 2 + 7) + 4 * (6 + (8 + 3 + 5) * 5 * 3 + 6 * 9)
 ((4 + 4 + 5 * 8 + 9 * 4) * 8 * 9 + 6 * 9 * 8) + 4 + ((9 * 2 * 7 + 5 + 3 + 6) + 3 * 4) * 8
 4 * (3 + 4 + 8 * 6 + 8 * 7) + 3 * 9 * 8 * 8
 (4 + 8) + ((7 + 3 * 9) * 5 * 8 * 4)
 3 * 9 + ((5 + 4 + 8 + 9) + 5 + 5 + 8 + 5)
 8 * (9 * 3 * (9 * 8 + 6 + 3) * 8 + 6)
 (5 + (3 * 7 + 6 + 9 * 7) + 8) + 2 * 3 * 7 + 2
 8 + 3 + 8 + ((3 + 6 + 8 + 2) + (4 * 9 * 7 + 5) + 6 * 2)
 (7 + 5 + 6 + (6 * 9 + 8 + 8 + 2 + 5) * 4 * (9 * 4 * 8)) + (8 + 5 * 3 * (2 + 8) + 7) + 8
 2 + (3 + (6 + 9 + 9 * 5 + 2) + 9)
 ((4 * 9 + 4 + 7) + 6) * 5
 2 * 3 + (7 + 5 + 9 + (9 + 9 + 8 + 5 * 8 * 7))
 7 * (4 + 4 * 7) * 4 + 2
 3 * (4 * 6) * 2 + 4
 2 * ((5 * 8 * 8 * 4) + 8 * 6 * 3 * 3)
 6 + (2 * (8 + 4) * 3 + 8 * 4) + ((3 * 9 + 6 * 4 * 8 + 3) + 9 * 9 + 3 + 3 + 2) * 4 + 6
 3 + 6 * 6 + (6 + 9 + 7 + 2) + 9
 (5 * 5 * (2 + 2 + 9 + 8)) + 7
 (5 * 7 * 6 + 9) * (6 + 4 + 9 + 6 * (8 * 2 * 2 + 5 * 9) + 6)
 9 * 7 + (2 * 2 * 8 + 9 * 7 * (8 + 4 * 8 + 4)) + (8 + 6 + 6)
 6 + ((3 + 9 * 4 + 7) * 3 * 8 + 4 + (3 + 3 * 6 + 6 + 8 * 5)) * 8 * 8 * 3 + 3
 5 + 3 + 6 + (2 + 3 * 9 + 2 * 8 * 8) + (6 * 6 * 5 * 6 + 6)
 (6 + 2 * 8 * 6 * 7) * 6 + 6 + 6
 (3 + (6 + 9 + 3 + 3 * 4) * 8 + 6 + 7 * 8) + (2 + 8 + 9 * 9 * 7) + 4
 2 + 7 + 2 + 3 + ((4 * 5 + 4 * 3 * 3 + 7) * 4 + 8 + 9 + (2 + 7 + 2 * 5 + 3) + 9) * 6
 (7 * (6 * 5 + 2 * 6 * 2)) + 9 + 6 + ((8 + 4) * 5 * 3 + 5 * 8) * ((5 * 5) + (8 + 4 * 5) * 8 + 4 + 2)
 ((4 * 6 + 2 * 5 + 8) * 9 * 3) + 3 + 5 + 3
 5 * 5 + (2 * 9 * 9 * 6) + 3 * 8
 3 + 7 * 2
 9 * (5 + 6 + 2 + (8 * 8 + 9 + 8 + 4 * 6))
 (9 + 2 * 7 * 2 + 5) + (4 + 6 * 3) + ((6 * 4 + 4 * 2 + 5) + 8 + 6 * 6)
 3 + (7 * (2 + 5 * 5 * 4 * 4 + 7) * 4 * 4)
 8 + 3 * ((3 * 7 * 3 + 4 * 5) * (6 + 8 + 9 * 7 + 6) * 9 + 5 * (5 + 4 + 4 + 4))
--- a/18/main.py
+++ b/18/main.py
@ -0,0 +1,106 @@
 import re
 def getExpressions(filename):
 	with open(filename, "r") as f:
 		return f.read().splitlines()
 def findMatchingPosition(line: str, pos: int) -> int:
    depth = 1
    end_pos = pos
    while depth > 0:
        end_pos += 1
        if line[end_pos] == "(":
            depth += 1
        elif line[end_pos] == ")":
            depth -= 1
    return end_pos
 def findMatchingParenthesis(line: str) -> list[tuple[int, int]]:
    parens = []
    for match in re.finditer(r"\(", line):
        paren_start = match.start()
        parent_end = findMatchingPosition(line, paren_start)
        parens.append((paren_start, parent_end))
    return parens
 def determineTopParenthesis(parens: list[tuple[int, int]]) -> list[tuple[int, int]]:
    top_parens = []
    for i in range(len(parens)):
        is_top_paren = True
        for j in range(len(parens)):
            if i != j and parens[i][0] > parens[j][0] and parens[i][1] < parens[j][1]:
                is_top_paren = False
                break
        if is_top_paren:
            top_parens.append(parens[i])
    return top_parens
 def evaluateExpression(expression: str):
    parens = findMatchingParenthesis(expression)
    top_parens = determineTopParenthesis(parens)
    top_parens.sort(key=lambda p: p[0])
    offset = 0
    for paren in top_parens:
        paren_start = paren[0] - offset
        paren_end = paren[1] - offset
        sub_value = evaluateExpression(expression[paren_start+1:paren_end])
        expression = expression[:paren_start] + str(sub_value) + expression[paren_end+1:]
        offset += (paren[1] - paren[0] - len(str(sub_value)) + 1)
    parts = re.findall(r"(\d+|[\*\+])", expression)
    result = int(parts[0])
    for i in range(1, len(parts), 2):
        if parts[i] == "*":
            result *= int(parts[i+1])
        elif parts[i] == "+":
            result += int(parts[i+1])
    return result
 def evaluateAdvancedExpression(expression: str) -> int:
    parens = findMatchingParenthesis(expression)
    top_parens = determineTopParenthesis(parens)
    top_parens.sort(key=lambda p: p[0])
    offset = 0
    for paren in top_parens:
        paren_start = paren[0] - offset
        paren_end = paren[1] - offset
        sub_value = evaluateAdvancedExpression(expression[paren_start+1:paren_end])
        expression = expression[:paren_start] + str(sub_value) + expression[paren_end+1:]
        offset += (paren[1] - paren[0] - len(str(sub_value)) + 1)
    parts = re.findall(r"(\d+|[\*\+])", expression)
    i = 1
    while i < len(parts):
        if parts[i] == "+":
            a = parts[i-1]
            b = parts[i+1]
            parts = parts[:i-1] + [int(a) + int(b)] + parts[i+2:]
            i = -1
        i += 2
    result = int(parts[0])
    for i in range(2, len(parts), 2):
        result *= int(parts[i])
    return result
 def part1(filename: str) -> int:
    total = 0
    for expression in getExpressions(filename):
        total += evaluateExpression(expression)
    return total
 def part2(filename: str) -> int:
    total = 0
    for expression in getExpressions(filename):
        total += evaluateAdvancedExpression(expression)
    return total
 if __name__ == "__main__":
    print("Part 1: ", part1("input.txt"))
    print("Part 2: ", part2("input.txt"))
--- a/18/test.txt
+++ b/18/test.txt
@ -0,0 +1 @@
 (9 + (5 + 2 + 2 * 4) * (7 + 7 * 5 * 3) + 7) + 2 + 4 * 2 + 3 * (8 + 5)
--- a/19/input.txt
+++ b/19/input.txt
@ -0,0 +1,605 @@
 25: 6 54 | 28 122
 52: 27 54 | 25 122
 44: 118 122 | 30 54
 37: 122 97 | 54 98
 38: 122 22 | 54 3
 77: 54 34 | 122 7
 17: 122 124 | 54 47
 1: 54 79 | 122 119
 13: 122 121 | 54 15
 29: 122 3 | 54 97
 24: 54 97 | 122 62
 80: 122 1 | 54 21
 62: 54 54 | 122 54
 5: 54 61 | 122 119
 28: 54 57 | 122 36
 101: 122 48 | 54 44
 81: 120 54 | 14 122
 14: 54 96 | 122 38
 18: 40 122 | 76 54
 27: 122 93 | 54 103
 4: 123 122 | 90 54
 65: 122 87 | 54 22
 113: 54 | 122
 23: 122 127 | 54 62
 117: 71 54 | 119 122
 53: 35 54 | 126 122
 26: 122 52 | 54 108
 125: 54 33 | 122 4
 10: 74 122 | 53 54
 84: 54 19 | 122 109
 123: 122 114 | 54 115
 42: 70 122 | 26 54
 16: 122 39 | 54 98
 63: 98 54 | 51 122
 39: 54 122
 76: 122 83 | 54 101
 61: 122 3 | 54 39
 50: 122 85 | 54 95
 78: 22 122 | 3 54
 114: 122 122
 64: 122 122 | 122 54
 40: 122 81 | 54 55
 92: 127 122 | 97 54
 119: 122 51
 57: 98 54 | 114 122
 3: 113 122 | 54 54
 97: 122 113 | 54 122
 7: 122 37 | 54 59
 74: 54 46 | 122 56
 2: 122 67 | 54 50
 48: 43 122 | 65 54
 124: 54 94 | 122 36
 82: 54 98 | 122 64
 93: 59 122 | 116 54
 96: 115 122 | 97 54
 98: 54 54
 60: 51 54 | 22 122
 72: 122 98 | 54 3
 106: 39 54 | 39 122
 41: 51 54 | 97 122
 31: 18 54 | 69 122
 91: 122 62 | 54 127
 120: 105 122 | 19 54
 56: 60 122 | 78 54
 47: 16 122 | 91 54
 88: 97 113
 30: 22 122 | 115 54
 71: 51 54 | 39 122
 87: 122 122 | 54 122
 21: 122 102 | 54 73
 43: 122 22 | 54 127
 35: 54 23 | 122 90
 51: 113 113
 90: 122 62 | 54 87
 32: 54 127 | 122 97
 115: 122 54 | 54 113
 55: 54 84 | 122 89
 73: 122 51 | 54 39
 36: 22 54 | 114 122
 68: 122 87 | 54 98
 34: 118 54 | 32 122
 95: 54 87
 83: 122 117 | 54 20
 33: 99 54 | 29 122
 19: 122 127 | 54 98
 46: 54 112 | 122 79
 89: 54 72 | 122 66
 110: 54 51 | 122 98
 109: 64 54 | 22 122
 9: 54 107 | 122 5
 12: 54 80 | 122 45
 104: 54 100 | 122 32
 15: 75 122 | 63 54
 69: 122 49 | 54 12
 8: 42
 75: 97 54 | 3 122
 108: 122 77 | 54 125
 103: 122 88 | 54 24
 111: 3 54 | 39 122
 70: 122 58 | 54 10
 20: 122 105 | 54 68
 0: 8 11
 122: "a"
 79: 62 54 | 22 122
 102: 87 122 | 97 54
 105: 98 54 | 98 122
 49: 13 54 | 2 122
 112: 54 39 | 122 62
 58: 9 122 | 17 54
 11: 42 31
 107: 66 122 | 110 54
 86: 54 106 | 122 82
 99: 127 122 | 39 54
 22: 54 122 | 122 54
 118: 54 3 | 122 64
 67: 122 59 | 54 111
 126: 78 54 | 92 122
 121: 54 41 | 122 38
 66: 22 113
 94: 54 39
 6: 88 122 | 29 54
 127: 122 54
 116: 54 39 | 122 87
 59: 54 51
 85: 64 122 | 97 54
 100: 98 122 | 62 54
 54: "b"
 45: 86 122 | 104 54
 baaabbaabababaaababaaaaababbbabaabbbabba
 baabbbbbaababbabaaabbabb
 abbabbaabbabbbaabbabaaaaaabaabbbabbabbaa
 bababbaababaabbaaabbabbb
 baaabbaababbbbaabbbaaaba
 bababbaababbbbbbaabbbbbb
 ababababbabbaababbaabbbabbaabababaaababbaabaaaabbbbbaaaa
 bbabbabaaaaabaaabbaabbab
 abbbaabbababaabbbaabaaab
 bababaaaabbbbbaaaabbbbbb
 bbabaabbbbabbaabbabaabbaabbbbbaa
 babaabaaabaaabbbbbbabbababaaabbbaaaaababbaabaabb
 abaaaaaabaaabbbabbbaaabaababaabaaabababaaabaabba
 aabbbaaaababbaaaaababbbb
 babaabbaaaaabaaabaabbbabbababbbb
 aabbabbbbbabaaaabbaabbab
 abbabaaaaaaaaaaaabaabbbbaaabbbabaaabbabb
 aaababbbaabbabbbaaabaaba
 babbaabbbabaaaaaaabbbbabbabaabbababbbbabaababbba
 abababbbabbabbaabaaabbbbababbabb
 aaaaabbbbbbbaaaabbbaaabb
 baababaaababaaabbaabaaabaabbabbabbaaaabb
 babaabbbababaabaaababbbb
 babaabaababbbbbbaabbaaba
 babaabbbbabaaaabbbabbbaaaabaaaba
 bbbabbbabbbbbaabbbbaabba
 aaaaaababbabbbaaaaabbabb
 bbabbbaaaababaaaababaaab
 baabaababbbbbbbaaaaababb
 abaababbaaaabbbaaabbabababaababbbbaabaab
 abbbbbaaaababaabbbbababa
 aabbabababbbbbaabbaaabba
 abbaaababaabbbaaaabbaaaabbbabbabbababababaaaaaaabaabaabaaaaabaabbaabaaabaababbbbbbaabbaa
 abbabaaaaaaaababbbbaabba
 bbabbbaaaaabaababbbbbaaabbaaaabababbbabaabbabaababaaababbaabbbbbaababbbb
 abbabaabbbbbaababbabbbbaabbaaaab
 baaaabababaabbabbbbbbaabbaaaaabbbabbbbba
 abbbabbbbbabaabbaaabaabb
 aaaaababbbbabbaabaababba
 baabbbbaaaaabbababababba
 bbbabbaaabbaaaaaabaabbaa
 babbaabbbabbaabbaaababababaaabab
 ababaabbbaaabaaabaaaababbbaababaaababaabbbbbabbaaabbaaaa
 aabbbabaaaaaabaaaaabbbaa
 aabaaabbbbbbbbbaaabababa
 abbaabababbbaabbbabbbbaaaaaaabbaaaababababaabbbabbbababa
 aabbbabbabbaaaaabbbaaabb
 bbbabbbabbaabbbbbbbaaaba
 bbabababaababbaaababbaab
 abbabbbabbbbbaaaabbabaaabbabaabaababbaaaaaabbabb
 abbbbaabbabaaababbabaaab
 aabbbbabaaaabbbaabbaabbbbbaabaaaaaaaaabaaaabbbaabaabaaab
 abaaabababbbbaabbbbbaaba
 bbbbbabbbabbbaaabbaababaaaabbabbaaaaaaabaaaaaaaaabbabaaaabbabbaabbbbaaabaaaabbba
 baabaabaabbbabbbbbaabaaaaaabbbaa
 bbbaaaaabbbbbbaabbaabaabbbbbbbbbabbababaaabbbbbb
 bababaabbabaabbabbbbbabababaaabb
 abaabbabaabaaabbbbaaabba
 babbaababbabbaababbbbaaa
 aabaababbabaababaababbbb
 aaababbaabbaaaaababaaabaaabbbabbbaaabababbbabbbb
 aaaaaabaabaabbbaabaaabaa
 babaabababbabaaaaaaababb
 bbabaabbabaabbbaaaaaaabb
 abbabbbbbaaabbaaaaabaaab
 ababaaaabbabbbaabababaaaaababaabbbaabbaaaababbbb
 babaaaaaababbbbaaabbbaaaabbbbbabbbababba
 bbbbabbbaababbabaabaabba
 babbabbbbaaaaabbbabbbaaaabaabaaa
 aabaaabbaabbbbabbbbababa
 babbabbaaaababbbaabbaaaa
 aabaababbaaabbbbbbbaabbb
 babaaaabbabaabbaabaaabababbaabbbbaaaabbb
 bbaabbbbbbabbbababbbabba
 bbbabaabbaabaabababbbaaa
 bbabaabbbaababbaaaabbbababbaaabaaaaabababaaaabbabbbaaabb
 ababaabababaabbbbbababaa
 abbabbaabbbbabababbababb
 baabbbbaaababbabaaabbaaa
 ababaabaababababaaabbabb
 babbbbaaabaabbbababbaaaa
 aaaabbabbabaaabbbbbaabbb
 babbababaabbbababbabababbababbba
 aabbbabbbaaabbaabbbabaaa
 aaaabbabbbbabbaaaaabbbba
 aaabbaabaaaaabaababaabbaababaaaababaabababbbaaaababbabaa
 babbabbabbaabbaaaaabbbbb
 bbababbbaaaabaaaabbaababbbaabaabaababbbabbbbbbaabbbaababbbbbbaabaaaaabbbaabbbbabaabbbbba
 aabbbabaaaaaabbbbbaabbaababbaaabaabaabbbaabaabbb
 bababaababbbbbaaabbaabab
 baaaaaababaaaaabbabbbbba
 aaababbabaaaababbbabbbaabbbbaabb
 bbabbbaabaaaababbaaaaaba
 abbbbbaaaabbbbababbbaaba
 bbbababbabbbaabbbbbbabaa
 abbbbabaabababbbbabaabaabbbaabba
 bbbbbbbaabbaabaabbbbaaaa
 bbbbbaaabaabaaaabaababbb
 abaaababbbbbbaaaaabbbaab
 abaaaaabbbbaaaabaababbaa
 baaaababbbabaabbaaabaaab
 aaababbbaaabbaababaaaaaabbaaaabaaaaabbaa
 bbabbaabbaaaababbbaababaaabbabba
 abaaaaabbbbaaaabbaaabaab
 ababbbaaabbabbabbabbaaab
 baaabbbbaaabbaababaabbabababbabb
 abbabbbbbbaaabbbbbaaaabb
 baabbbaaabbbabbbbababbaabbbbbbbbabbaaaabbbaababbbaaaaabbbabaabbaaababbbbbabaaaba
 aababbaabbbbbababbbbabbabbababbaabbaabbaaaaaaaab
 bbbbaaabaaabababbbabbababbbaabab
 bbaabababbaaabbbaaaababb
 abbbaabbbaabbaabbaababba
 aabababbbabbbbaabaaaaaabbbaabbabbabbabbb
 babbbbbabbbbbbbaaaaaabaaababbbbaaaabbaaa
 babaabbaaabbabababbbbbbb
 bbbaabaaabaaaaabbabaaabbaabaabaa
 babbababaabaababababaabaababaaab
 bbaaaaababbabbabbbbbaabb
 babbbabbabaaaabbabaabaaa
 babbababbaabbaabbbaabaab
 abbabaabbaaabaaaaabbbabbbbabbabaaababbbbbabaabba
 bababbaabaabbbabbbabbbbb
 babbbbbbbaaaaabbbbababaa
 baaaaaababbabaabbaaaaaba
 aabababbbbaababaabbaabaaaaaabaaabaababba
 abaaababbaabbabbaaaaababaabbaabbabbaaaabbbbaababababaaba
 bbbabbbababbbabbbbbaabaaaababbaababaaaaabaababaaabbaabababbaabab
 aaababbbbbabaabaababbaab
 bbbbaaabbbbabbbabbbbaaaa
 bbbabbababaaababaaaababb
 baabbbbbbbabaababababaabaabbaaaaaabbabaa
 abbabbaaaaaabbbaababbbbb
 bbaabbbbbaaabbbbbbbaabba
 bbbaaaababbabbabbaababab
 baaabbaababaabaaabbbabab
 ababaaaaaabaaabbabaabbaa
 aababaabbababbaababbababbbaabababaabbabababbabaaaaababaaaabbbaabaabaabaa
 bbaababababbabbaababaaab
 aaabababababbbbabbbaabab
 aabaaaaabaaaaabbaaaaababaaabbaabbaabbbabbaababab
 bbaaabaaaaabaabbabaaaaba
 babbbbabbabbbbaaabbaaaaaabbaabbababababb
 abbbbaabaaababbbbabbabbabbaabaaabbbbbbbbbaaaabaabbaaabab
 abbaaaaaabbbbabbabaabbbbaaaabababbbbaaba
 bababaaaababbbbaaaababbaababbaaababaaababababbbbaaabbbba
 baaabbbbabaaaaabbbbbbbbb
 bbbbbabbaaaabaabababbbbb
 ababaaaaaaababbabaaaabba
 abbbbaabbbaabbbabaaababa
 abaaababbabababaaabaabaa
 baaaababaaabaaabbaabaaab
 abbbbabababbabbaaabbbabbaabaaabaaabababaabbbabab
 babaaabaaabaabababbaaaab
 bbabbabbbabbaabbaaaaaabababababbbaabababaaabaababbaabbab
 abbaabbbbabaabaaaaababaa
 bbaabbaaaaababbaabbbaabbbbabbabaaabbbababbaabbaaaabbbbaa
 bbbbababbbbababbbbbabbaaaaaabaabbbbbaabb
 babbabbbabbabbaaabbbbbaa
 abababbbbbabbabbabbaaabb
 bbaabbbabbbbababbbabbaaa
 baabbabbbbbabbabbbabbbba
 aabaababbabbbabbbababbbb
 babbababbbabaababbbaabba
 aaaabbababbbbaabbbabbabbbabaaabbbaababaabaababbb
 abbbaabbabbbbbaababababb
 abbaabaabbbabbaaababbabb
 baabbabbbaabaaaaaaaaabba
 bbaabababaaaaaabababaabaabaaaaabaabbbbbbabbbbaaa
 babaabababbaaaababaababababbbaab
 aaaaabbbbbabaabbbaababab
 bbbbbaababbbbaabaaabbaba
 abbabbaaababaabbbbbaabaabbababab
 bbbabaabababbbabaaaababa
 baaabbbababbaababbbbabba
 aaaabbaabbaabbbabbbbaaaa
 aabaaabbaabbaabbabbbbbab
 bbbababbbababbaaabaaabba
 abbbbbaaabbaaaaaabbaabba
 babaaaababbbbababaaaabbb
 baaabbbaaaababbabbbaaaaa
 bbbababbababbaabbbabbbbb
 aabbbbababaabbbaabaaaaaa
 abaababbaaaaabaababbababababbbaaabaaaababbbaabbb
 babaaaababbaabaabbbbaaaa
 baabbabbabbbabbbaabaababbabaaaaa
 babbbbbbabbbabbbaaabbabbaabababaaabaaaba
 abbabbbaabbaabaabbaaaaaa
 bbbabbaababbbbaabaaababb
 abaabbabaababbaabbaaaabb
 baabbabbbabbbabbabbbaaab
 abbbbaabbababbaababaaaaaaababbaabbababaa
 ababababbbbbabababaaaaaa
 bbbaaaabbabbaabbbabbbabbbbababaa
 bbbbbbbaabbabbbbbbbabbbb
 baaaaaababbabbbabbbbbbbaaaaaaabbbaaababb
 bbabbbababbaaabaaabbabaaabbabbbabbabbbaaababbbab
 bbabbaabbbaaabbbabaaabbbabaabbaabbaaabba
 abaaaaabbbaababbababbbabbbbabaabaabbaabbbbababbbababbaaaabaaabaabbaaabaa
 bbabaabbaabbaabbaabaabbb
 baabbaaabbabababbaababab
 bbaababaaabbbaaababbbaba
 babaaabaabaabaabaaabbaabbaaabbaabaabaaba
 babaabbabaababaabbbaaaaa
 bababbaaabababababaaaaba
 aaaabbabbabbaababbaabbab
 abbabababaaabbbaaaabaabbbbaabaabbababbbbbbbbaaabbaaababbabbbbaaabbaaabab
 bababaabaaaabaaaabababbbabbaaaba
 aabbbbabaabbaabbbbbabaabbaababbabbaaabababbbbbba
 baabbabaaabbbbabbbaaabaa
 bbbbbababababaabaaababaa
 aabaabbaabaaaaabbbbbabababbababb
 baabbabbaabbbbabbaaababa
 aababbaabbaabababbaabaab
 baababaabbbabbbaabaabaab
 aaaaabaaaaaaaabaaabaaaab
 abbabbabaabbabbbabaabbbabaababaababbbbbbaaabbaaaabaaabaa
 aabbbbabbbaabababaababbb
 aabaababbababaaaabbaabba
 aabbaabbbabaabaabbabbbbb
 bababaaaabbbbbaabbbaabbb
 babbbaaababbbaaaaaaabbbb
 aabbbabaabbbabaabbbaabbb
 aaaabbaabbbbabbbbbabaabaabaaabaa
 abbabbaaabbabbbaabbbaaba
 ababaabbbbabababaaabbaaa
 aaabababaaaaabaaaaaaabbbbbbbabababbaaabaabbbaaab
 baaaababbaababaaabababaa
 aaaabbaaabbbabbbbaaaabba
 abaabbbbbaaaaaabaababbaaababbaabaabababa
 abbabbbbababbbaabaabbaaabbbbbbaabbbbabaa
 bbabbabbbbabaabbabbbaaab
 aabbbababbbaaaabaabaabbb
 bbbabaabbaaabbbbbaabaabb
 ababaabaaaaaababaaabbaaa
 baaaaaabbabbabbaabbbaaab
 bbabaabaababaaaaabbabaaaabababba
 aabbbaaaaaabbaabbbabbaabbaabaaaa
 abaaabbbbbaaabbbbaaabbab
 bbabbabbabaaabbbbabbbbbbabbbbbbaababaaaaabbbbbabaaababbabbbabaababaabbbbabbabbab
 babaabaababababaaaabbbba
 bbaabaaababbbbbbbaabaabb
 baabbbabababaaaaaabbbbaabbbaabab
 abbbaaaababaabbabaabbbabbabbaaabaaabbaababbbbaaa
 abbbabaabaababaaabbaaaab
 ababababaabbbbabbbbbbbabbbbabbbaaaaaaabbbaabbabaabaaaabb
 abaaabbbabaabbababbaabaaaaaabbbaaaabbbba
 baaaaabbababababbaaabbab
 babaaabaaabbbaaabaaabbaa
 babbbabbbabaabaabbbbbbbb
 aabbbabbabaaababaaabbabb
 bbaabbaaaaababbaaabbbaab
 aabbbbabbbbabbbaaabaaaab
 abaabbbaababababbabaaabbbabbbaba
 abbaaaaabbabbbabbbaaabba
 aabaababbaabbabbabbaabba
 bbabbabbbabbbbaabaababba
 bbabaabbbbabaabbbbbbaaaa
 abbbbabaabbbaabbaaababbaabbbabbaaaaababb
 bbaaabbbbabaabbaabbbbbbb
 abaaaabababbaaababbbbbbaababbaab
 abaabbbbababaaaabbbaaabb
 aaabaabbaababbbbbbbaaaaaabbbaaba
 aaaaababbaabbaabbabbabbb
 aaaaaaabaabababbbbbaaaaa
 bbbbbaaaababaaaaaaabbaba
 ababbaaababbbaaaaaabbbba
 babaabbbbbabababbaabaaab
 aabbbababbbabaabaabbaaab
 abbbabaaabbbaabbabbaabba
 baabbaababaabbabaabaaaab
 baabbabbaabaababbaababbb
 bbbaaaabaabbbaaaaaaaaaaabaaabbbaabbaaaaaabbbaababaabababababbaabaaabbbab
 baabbabaaaaabbaaabbbabba
 babaaabbabbbaabbabbababa
 bbabbabbaaababbbbbbaaabb
 aaaaababbabababaaaaababa
 babaabbbbbbbbbbababbbbbbbbbaaaabaababaaa
 aaabababaababbaabaaababa
 ababaabbbabaabaabbaaaaaa
 aaaabaaaabbabaaababaabaabababaabbaabbbbbaabbbbba
 baaaaaabbabaabaabbaababb
 aaabababaaabababaabaabba
 abbabaaaabbabbbbbbbbbabbaaaaabab
 bababaaaaababbabbbbbbbbb
 ababbaaabbbbababbaaaaaba
 ababaaaabbbaabaabbaaabaa
 baaabbaabbbaababbaabaaabaaaaabababaabaaabababaaa
 aaabbaabbaabbabbbbbababbabaaaababaaabaab
 bbbbbaaabbaabbaababababb
 aabbbbabaaaaabbbbaabaabb
 abbabbaaaabbaabaaaaababbabbabbbaabbbbbbaabbabaaababbaabaaabbabab
 abbabbababbbbababbbaabaabbbaaababbbaaabb
 bababbaaabaabbabababaaaaabbbabbbaaaaabbb
 babbaabaaabbaabbbbaaabaa
 ababbaaababababaabababbbbbaababaabbbbbbb
 aababaabbbabbaabababababbbbabbbaaaabaaabaaabbabb
 baabaaaabababaaaababbbbb
 bbbbabbbabaaabbbbbbababa
 bbabbbaaaabbbaaabaababbb
 bbbabbabbaabbabbbaababbb
 baabaabaaaaaababaabaaaab
 aabaabbaabaabbbbaaaabaaabbaababbbbbababbbabbbababaaabaabbaabbaabababaaab
 babbababbbbababbabbbbbaaaaabbbaa
 bbaabbbaaabaaabbbaababba
 bbabbbabbbbabbbabbbbaaababbabaaaababbaabaaabaabbabaaabaa
 abbaabbbabbbbabbbaaabbaaaabaabba
 baaaaabbbabaaabababaaabbbabababaaababaaabaaaabbaabbaaababababbbaabbbbaaa
 babbbaaabaaabbbbbbababba
 aabbbbabbaabaaaababbabbb
 baabbbbababbbbbbbbbbaaba
 baabbbabbbaabaaababbaabbabbbababbbabaaab
 bbabbbababbabbbbababbaaabababbbbabaabbaa
 aaabababbbbbababaabababbbbbabbbbbabbbaba
 bbbbabbbbaabbbabbababaaabbbaaabaabbababb
 ababbbbaababbbabbbababba
 abbaaaaabaabaaaabbbbaaba
 aaababababaabbabbbbbbaaaaaaababa
 bbbabbbabaaabbbbbbabbaabbbbabaaa
 bababaabbabbbabbaaabbbaa
 abbbbabbaaaaabbbbababababbbbabbbaaaaabaaaabbaaaa
 bbabbbaaaabaaabbaaaabbaabbabaaab
 abbabaaaaaaaaaaaaaabbabb
 babbbabbbbabaabaabaaaaba
 babbaabaabaaabbbbbbbbbaa
 ababbbbabbbbabbbbababaaaabbaaabbbbbaabba
 aabaababababaabbbbbaaaaa
 abbbbbaaabbbbabbaaaababa
 aaabaaabaabbbaabaabababaaaabaaba
 babbbabbbbaabaaabababbbbbabbababbaabaabb
 babaabbbbbbabbabaaaabbbaabaaabaaaabaabba
 bababaabbabaababbabbbabbbbbbababbabbaaaaaabbabaa
 babaaaabaababaabbbbaabba
 bbaabbbbbaaabbbaaabbbbabbbaaaaabbabbabbababbabaabaaabababbabbbba
 baabbaabbbabbababbbabaaa
 aaaaaaaaababbbababababbbbbabaaaabaaaaababaabbbbb
 aaaabaaabaabbbbbbbabbbabbabbabaabbbbaaabaaaabbbbbabaabaa
 aabaabababbbaabbbbabaabbbbaabababbabbabaaaabaabb
 aabaababbbabaabababbbbab
 bbaabbbabbbabbbabbabbbba
 bbaaaaabaaaabbaaaaaaabba
 bbaaaaabaababbaababbbabbabbabbaa
 aaabaabbbabaabaaaaabbbabaabbbbbabbbaabaa
 aaabbbaabbbbaaabababbbbbabbbbbbbbbbabbbaabbabbbbaaaaaababbbbabbaabbabbaaaababbbb
 aababaabaabbababbababbba
 babaaaaaaaaaaaabaabaabba
 aaabbaabbabbaabbbaabbbbbaabbaaba
 aaababbabbabbabbababbbbb
 abaaabbbbbaabaaaabbaaaba
 bbaababaababbbabaabbbaab
 abbbaabbbaaabbbabaabbbbbaaaaaaabbaaaaabbbbbbabaaabbaaaba
 babaaaabbabaaaaababbabaa
 bbbbaaababbbbaabababbbbb
 abbababbaabaababbbaaaaabaabaabbbbabbabaababababaaaaaabbababbabbbbabbaaaabbbbabaa
 babaaababbabaaaabbaaaaba
 bbabbabaabbbbababbbaaabb
 bbaababaaaaabbbaaaabbaaa
 babaaaaaaabaababbabbabbaabababbbaaabbbaaaabbbbbabbbbaaaa
 babaabbababaaabbbaaaabbb
 aabaababbabbbabababbbbaabaaabaaaaaabbababbbabaaaabaaaaabaaaababaaabbbaaabbaaabbb
 abbbabaabbbaaaabaaabaabb
 bbbbbbbaaaabababaabbbbbb
 ababaaaabbababababbaaabb
 abbabbabbabbaabbbaaaaabbaabababa
 bbabbabaababbbabaaaababb
 babbabbababaaabbabbaaaba
 aabbaaababbaaabbbbaabaabbbbabbbaaabbbbababbbabbaaabaaaabaaaabaabaabbbaab
 bbbbbbbaaabbbabbbbaaaabb
 bbabbaabbbbaabaabbbaaaaa
 bbbabaabbaabbaaabaaabaaabbbbbbbb
 aaabababbaabbbbaaababbbb
 abbbbbbbabaaaaaaabbbbababbababaa
 bbbaaaabaabaaaaabbaabbab
 bbbbabbbaaaababbaabaaaab
 bbaaabbbababbbabbbbbabaa
 aaaabbaaabaababbbbabbabbbbbbbaaaabbbbbba
 aabbbabbaaaaabbbbaaabaab
 abbabbbbbaaaaaabaaabbaaa
 baaaabababbbbaabaababaaaabaaabbbbbbaaaababbababa
 bbbbabbbbbbbabbbbabbabbb
 abbabaaaaabbaabbabaaaaaa
 abbabbaaaababbaaababaababbbaabbbabbaaaab
 abbaabaaaaaaabaaaaabbbaa
 bbbaaaabbaabaabaaabababa
 bbbaababbbbabaaabbbabaabaabababa
 baabaababbabababbbbaaaaa
 baaaabababbaabbbbaabbbabbbbaabab
 baabbbbaababbaaaabbaabbb
 babbbbbbabbbbabbabbabbabaabaaabbaaabbbab
 ababaabbbabbaabbabaababbbbbbbaba
 baabbabbaaabababbaabaabb
 ababababbbabbbabbbababaa
 abbaababaabbbbbabbaaabbabbabaaab
 babbbbaaababbbabbbababba
 abababbbabaaababaabbbbbbbbabbbbbbaaaabbbaabaaababababbba
 aabbaabbbabaabbbbabbbbab
 baabbbbabbbbabbbbaaababa
 aaababbbbbbabbaabbbaaabb
 bbbaaababaabaaabaababbbabaaaaabaaaabbbaa
 baaabaabbabbaaabbaaababa
 bbabaabbaababaaaababbbbb
 ababbbbababbabbababaabaaaaaaaaababababbbaabbbaab
 bbbbbabaabbbaabbaaaaabba
 aaabababbbabbaabbbaabaab
 bbabbabbbabaabbabaababbb
 aaaaaaababbabbabbabbabaa
 abbabaaaaaaaaaaaababbbbb
 babaababbaabbabbabbabbaabababbbaabaabbaa
 aabbbbaaaababbbbabababbabbbababa
 bbbabbaabbabaaaaaaabaaaa
 bbabbabaabbaaaabbbaaaaaa
 bbaabaaabbabaaaabbbbaabb
 bbabbaababbabbaaabbbabbbababbaab
 bbbbababbabbaabbaabbaaab
 aaaabbababbabaaababbbbbbbbbbbababbbababbabbbaabaaaabbaba
 abbbaaaababbbbbaaaabababababbaabaabbbbaabaabaabbbabababa
 bbbbabbbbbbbabbbbbbbbbab
 bbabababbbabaaaababababb
 abbabaaaaaaabbbaaaabbbbb
 baababaaabababbbbabbaaaa
 bbabbabbbabbabbaabaaabba
 aaabababbabaabbaaaabbbbb
 abaaababbaabbbbaaaaabbaaaaaabaaabbabbbabbbabbbbb
 bbaaabbbbbbababbabababba
 bbbbaaabbbabbbabbabaaabbbabaabaaaaaaababbabababbbbbbabaababbabbb
 babbbabbbaaabbabbbabaaabababbaba
 bbbabbbbbbabbabbaababbbb
 baaabaaabbaabbaabaaabbabbababbab
 bbabaaaaabbabbaaabbabaab
 abbaabaabaaaaabbbbbaabba
 aabbbbbaaaabbbbaabaaabbbbbaaabbaaababbbaaabbbaababababbaaabbbaabbbabaaab
 bbbabbbaabbbbababaaabbabaabaabbbbababbaaaaaaabbbaaabbbabaababbaabbaaabaaabababba
 aaaaababbbbbbaaaabaababbabbbbabaaaabbaabaabaabbabbabbbbbaaaaabba
 babbabbabaabbbababaaabaa
 aabaaaaabbbbaaabababbaab
 babaaabbbabaabbbaaabaaba
 bababaaabbaabababbbbaabb
 aabbbababbaabbbaabbababb
 babaabaabbbbaabbaaaaabababaaababaababbabbabbabbaabbbbbaababbaabbaaaabaaa
 aabbbbabaaababbabbaaaaaa
 ababaabbabaababbbbbaaaaa
 aaababbbbaabbbabbbabaabbaabbbabaabbaababaaabbaaa
 bbbbaaabbbaabababaababbb
 ababababaabababbbbababaa
 baaabaaaabaaabbbabbbbbaababaaabaabaaaabaaabaabaaaaabaaaa
 abaabbbabaaabaaaababbbababbbbbaaaabaabaa
 bbaabaaabbbbbbbbbaaabaaababbbbbabababbaabaaaaaba
 babbababaabaaaaaaabaabba
 bbbabaaaabbaabbbaabaabbbaaabababaaababaabbbabaaabbbbaababaaaaaabbabbbaba
 aabaaaaaaabbabbbaabbbbba
 abbbbababbabaaaaaaaaaaaaaabbbaaababbabbabbbbabaa
 aaababbabababaaaabbaabba
 bbbbabababbabbbaabbbabab
 aaababbbbaabaaaabbbaabbb
 bbbaaaabaabaaabbbbaaabab
 ababbbaabaabaabababbbbab
 babaabababbabbbbbbbbabba
 abbbabbbabaaabbaaaaaabbbabababbabaaaaaab
 baaabbbbbababaababbbbbbb
 aabbbaaaaabaaaaaabbababb
 aaaaabaaabababababbbbaaa
 ababaabbaaaabbababaaaaaa
 bbbaaaabaaaabbaabaaabaab
 baaabbbbbbbabbaaabbaaaaababbabbbbbbaabbbbbbabbbabbbaaaab
 bbbbbaabaaaabbabaaaaaaaabbbabbbb
 bbbaabaaaabbabbbabbaabaaaaabbbbbabbababbaabbbababbababab
 bbabbabbbaabbaaaabbabbaaabbbabaababbabbaaaabbbab
 baaabbbababbbabbaabaabbb
 aaaabbaababababaaabbbbbb
 abbbbbaabbbabaabbababbba
 bbbbbbbababbaabbabaaabba
 abbbaabbbabaababbbaaaaabaabbbbaa
 babbaabaabbbbababaaabbab
 baaabbbabaabbbbabbbbaaabaaabbabb
 aabbbabbabbbbabbababaabababaabaabbaaabaabbbbbbbbaabababa
 bbbaabaaababaaaabbaabbaaaabbbabaabababaa
 bababbaababbababaabbabaa
--- a/19/main.py
+++ b/19/main.py
@ -0,0 +1,73 @@
 Rule = list[list[int]]|str
 RulesDict = dict[int, Rule]
 def parse_rule(rule_str: str) -> Rule:
    if "\"" in rule_str:
        return rule_str[1]
    else:
        rule = []
        for sequence in rule_str.split(" | "):
            rule.append(list(int(n) for n in sequence.split(" ")))
        return rule
 def parse_rules(rules_str: str) -> RulesDict:
    rules = {}
    for line in rules_str.splitlines():
        id_sep = line.find(":")
        id = int(line[:id_sep])
        rules[id] = parse_rule(line[id_sep+2:])
    return rules
 def parse_input(filename: str) -> tuple[RulesDict, list[str]]:
    content = None
    with open(filename, "r") as f:
        content = f.read()
    rules_part, messages_part = content.split("\n\n")
    rules = parse_rules(rules_part)
    messages = messages_part.splitlines()
    return rules, messages
 def find_match(message: str, rule_id, all_rules: RulesDict) -> list[int]:
    rule = all_rules[rule_id]
    if isinstance(rule, str):
        if message.startswith(rule):
            return [1]
        else:
            return []
    result = []
    for sequence in rule:
        branch = [0]
        for id in sequence:
            new_branch = []
            for last_pos in branch:
                match = find_match(message[last_pos:], id, all_rules)
                for pos in match:
                    new_branch.append(pos + last_pos)
            branch = new_branch
        result += branch
    return result
 def matches_zero_rule(message, rules: RulesDict):
    return len(message) in find_match(message, 0, rules)
 def part1(rules: RulesDict, messages):
    count = 0
    for message in messages:
        if matches_zero_rule(message, rules):
            count += 1
    return count
 def part2(rules: RulesDict, messages):
    # 8: 42 | 42 8
    # 11: 42 31 | 42 11 31
    rules[8] = [[42], [42, 8]]
    rules[11] = [[42, 31], [42, 11, 31]]
    return part1(rules, messages)
 if __name__ == "__main__":
    rules, messages = parse_input("input.txt")
    print("part1: ", part1(rules, messages))
    print("part2: ", part2(rules, messages))
--- a/19/test.txt
+++ b/19/test.txt
@ -0,0 +1,47 @@
 42: 9 14 | 10 1
 9: 14 27 | 1 26
 10: 23 14 | 28 1
 1: "a"
 11: 42 31
 5: 1 14 | 15 1
 19: 14 1 | 14 14
 12: 24 14 | 19 1
 16: 15 1 | 14 14
 31: 14 17 | 1 13
 6: 14 14 | 1 14
 2: 1 24 | 14 4
 0: 8 11
 13: 14 3 | 1 12
 15: 1 | 14
 17: 14 2 | 1 7
 23: 25 1 | 22 14
 28: 16 1
 4: 1 1
 20: 14 14 | 1 15
 3: 5 14 | 16 1
 27: 1 6 | 14 18
 14: "b"
 21: 14 1 | 1 14
 25: 1 1 | 1 14
 22: 14 14
 8: 42
 26: 14 22 | 1 20
 18: 15 15
 7: 14 5 | 1 21
 24: 14 1
 abbbbbabbbaaaababbaabbbbabababbbabbbbbbabaaaa
 bbabbbbaabaabba
 babbbbaabbbbbabbbbbbaabaaabaaa
 aaabbbbbbaaaabaababaabababbabaaabbababababaaa
 bbbbbbbaaaabbbbaaabbabaaa
 bbbababbbbaaaaaaaabbababaaababaabab
 ababaaaaaabaaab
 ababaaaaabbbaba
 baabbaaaabbaaaababbaababb
 abbbbabbbbaaaababbbbbbaaaababb
 aaaaabbaabaaaaababaa
 aaaabbaaaabbaaa
 aaaabbaabbaaaaaaabbbabbbaaabbaabaaa
 babaaabbbaaabaababbaabababaaab
 aabbbbbaabbbaaaaaabbbbbababaaaaabbaaabba
--- a/20/input.txt
+++ b/20/input.txt
--- a/20/main.py
+++ b/20/main.py
@ -0,0 +1,238 @@
 from dataclasses import dataclass
 from typing import Iterator, Optional
 from math import floor
@dataclass
 class Tile:
    top: str
    left: str
    right: str
    bottom: str
    inner: list[str]
    def __repr__(self) -> str:
        return "Tile"
 TilesData = dict[int, Tile]
 TileGrid = list[list[Optional[tuple[int, Tile]]]]
 def parse_tile(tile_data: str) -> tuple[int, Tile]:
    lines = tile_data.splitlines()
    id = int(lines[0][4:-1])
    top_edge = lines[1]
    right_edge = "".join(line[-1] for line in lines[1:])
    left_edge = "".join(line[0] for line in lines[1:])
    bottom_edge = lines[-1]
    raw_inner = list(line[1:-1] for line in lines[2:-1])
    return id, Tile(top_edge, left_edge, right_edge, bottom_edge, raw_inner)
 def parse_input(filename: str) -> TilesData:
    tiles = {}
    with open(filename, "r") as f:
        content = f.read()
        for block in content.split("\n\n"):
            id, tile = parse_tile(block)
            tiles[id] = tile
    return tiles
 def flip_image(image: list[str]):
    return image[::-1]
 def rotate_image(image: list[str]):
    return ["".join(col[::-1]) for col in zip(*image)]
 def rotate_tile(tile) -> Tile:
    return Tile(
        top = tile.left[::-1],
        right = tile.top,
        bottom = tile.right[::-1],
        left = tile.bottom,
        inner=rotate_image(tile.inner)
    )
 def flip_tile(tile) -> Tile:
    return Tile(
        top = tile.bottom,
        right = tile.right[::-1],
        bottom = tile.top,
        left = tile.left[::-1],
        inner=tile.inner[::-1]
    )
 def get_grid_size(tiles: TilesData) -> int:
    return floor(len(tiles)**0.5)
 def get_rotated_tiles(tile: Tile) -> Iterator[Tile]:
    yield tile
    tile = rotate_tile(tile)
    yield tile
    tile = rotate_tile(tile)
    yield tile
    tile = rotate_tile(tile)
    yield tile
 def get_tile_variants(tile: Tile) -> Iterator[Tile]:
    for t in get_rotated_tiles(tile):
        yield t
    tile = flip_tile(tile)
    for t in get_rotated_tiles(tile):
        yield t
 def get_image_variants(image: list[str]) -> Iterator[list[str]]:
    yield image
    image = rotate_image(image)
    yield image
    image = rotate_image(image)
    yield image
    image = rotate_image(image)
    yield image
    image = rotate_image(image)
    image = flip_image(image)
    yield image
    image = rotate_image(image)
    yield image
    image = rotate_image(image)
    yield image
    image = rotate_image(image)
    yield image
 def is_tile_possible(grid: TileGrid, x: int, y: int, tile: Tile) -> bool:
    if x > 0:
        other_tile = grid[y][x-1]
        if other_tile and other_tile[1].right != tile.left:
            return False
    if x < len(grid[0])-1:
        other_tile = grid[y][x+1]
        if other_tile and other_tile[1].left != tile.right:
            return False
    if y > 0:
        other_tile = grid[y-1][x]
        if other_tile and other_tile[1].bottom != tile.top:
            return False
    if y < len(grid)-1:
        other_tile = grid[y+1][x]
        if other_tile and other_tile[1].top != tile.bottom:
            return False
    return True
 def get_possible_tiles(
        tiles_data: TilesData,
        used_tiles: list[int],
        grid: TileGrid,
        x: int,
        y: int
    ) -> Iterator[tuple[int, Tile]]:
    for id in tiles_data.keys():
        if id not in used_tiles:
            for variant in get_tile_variants(tiles_data[id]):
                if is_tile_possible(grid, x, y, variant):
                    yield id, variant
 def solve(tiles_data: TilesData, grid: TileGrid, used_tiles: list[int] = []) -> bool:
    for y in range(len(grid)):
        for x in range(len(grid[0])):
            if grid[y][x] == None:
                for id, tile in get_possible_tiles(tiles_data, used_tiles, grid, x, y):
                    grid[y][x] = (id, tile)
                    used_tiles.append(id)
                    if solve(tiles_data, grid):
                        return True
                    used_tiles.pop()
                    grid[y][x] = None
                return False
    return True
 def multiply_corners(grid: TileGrid) -> int:
    w = len(grid[0])
    h = len(grid)
    top_left = grid[0][0]
    top_right = grid[0][w-1]
    bottom_left = grid[h-1][0]
    bottom_right = grid[h-1][w-1]
    assert top_left
    assert top_right
    assert bottom_left
    assert bottom_right
    return top_left[0] * top_right[0] * bottom_right[0] * bottom_left[0]
 def solve_grid(tiles_data: TilesData) -> TileGrid:
    width = get_grid_size(tiles_data)
    grid: TileGrid = []
    for _ in range(width):
        grid.append([None]*width)
    solve(tiles, grid)
    return grid
 def get_full_image(grid: TileGrid) -> list[str]:
    rows = []
    for y in range(len(grid)):
        row = []
        for x in range(len(grid[0])):
            cell = grid[y][x]
            assert cell
            inner = cell[1].inner
            if x == 0:
                row = inner.copy()
            else:
                for i in range(len(inner)):
                    row[i] += inner[i]
        rows.extend(row)
    return rows
 def is_sea_monster(image: list[str], sea_monster: list[str], x: int, y: int) -> bool:
    for oy in range(len(sea_monster)):
        for ox in range(len(sea_monster[0])):
            if sea_monster[oy][ox] == "#" and image[y+oy][x+ox] != "#":
                return False
    return True
 def count_symbol(image: list[str], symbol: str) -> int:
    return sum(sum(c == symbol for c in row) for row in image)
 def count_sea_monsters(image: list[str], sea_monster: list[str]) -> int:
    monsters = 0
    for y in range(len(image)-len(sea_monster)+1):
        for x in range(len(image[0])-len(sea_monster[0])+1):
            if is_sea_monster(image, sea_monster, x, y):
                monsters += 1
    return monsters
 def part2(grid: TileGrid) -> int:
    image = get_full_image(grid)
    sea_monster = [
        "                  # ",
        "#    ##    ##    ###",
        " #  #  #  #  #  #   "
    ]
    max_monsters = 0
    for variant in get_image_variants(sea_monster):
        monsters = count_sea_monsters(image, variant)
        max_monsters = max(max_monsters, monsters)
    return count_symbol(image, "#") - count_symbol(sea_monster, "#") * max_monsters
 if __name__ == "__main__":
    tiles = parse_input("input.txt")
    grid = solve_grid(tiles)
    print("part1: ", multiply_corners(grid))
    print("part2: ", part2(grid))
--- a/20/test.txt
+++ b/20/test.txt
@ -0,0 +1,107 @@
 Tile 2311:
 ..##.#..#.
 ##..#.....
 #...##..#.
 ####.#...#
 ##.##.###.
 ##...#.###
 .#.#.#..##
 ..#....#..
 ###...#.#.
 ..###..###
 Tile 1951:
 #.##...##.
 #.####...#
 .....#..##
 #...######
 .##.#....#
 .###.#####
 ###.##.##.
 .###....#.
 ..#.#..#.#
 #...##.#..
 Tile 1171:
 ####...##.
 #..##.#..#
 ##.#..#.#.
 .###.####.
 ..###.####
 .##....##.
 .#...####.
 #.##.####.
 ####..#...
 .....##...
 Tile 1427:
 ###.##.#..
 .#..#.##..
 .#.##.#..#
 #.#.#.##.#
 ....#...##
 ...##..##.
 ...#.#####
 .#.####.#.
 ..#..###.#
 ..##.#..#.
 Tile 1489:
 ##.#.#....
 ..##...#..
 .##..##...
 ..#...#...
 #####...#.
 #..#.#.#.#
 ...#.#.#..
 ##.#...##.
 ..##.##.##
 ###.##.#..
 Tile 2473:
 #....####.
 #..#.##...
 #.##..#...
 ######.#.#
 .#...#.#.#
 .#########
 .###.#..#.
 ########.#
 ##...##.#.
 ..###.#.#.
 Tile 2971:
 ..#.#....#
 #...###...
 #.#.###...
 ##.##..#..
 .#####..##
 .#..####.#
 #..#.#..#.
 ..####.###
 ..#.#.###.
 ...#.#.#.#
 Tile 2729:
 ...#.#.#.#
 ####.#....
 ..#.#.....
 ....#..#.#
 .##..##.#.
 .#.####...
 ####.#.#..
 ##.####...
 ##..#.##..
 #.##...##.
 Tile 3079:
 #.#.#####.
 .#..######
 ..#.......
 ######....
 ####.#..#.
 .#...#.##.
 #.#####.##
 ..#.###...
 ..#.......
 ..#.###...
--- a/21/input.txt
+++ b/21/input.txt
@ -0,0 +1,34 @@
 rzfcn jcpnmh sjxxzrd qpngxk vpchddj ccjjp klcl dk bltzkxx ttzd fkszg rhjbx cnnd shptr mhvtp zlcbnx tplp vgh bltrbvz qbrr bhgpk ffmgfz tgfcl kjfnqg rpf sncl jvjmd jgblz ngzp dvrhz zphlmnb spql crsp hqnnsm hvlc pxldx pflk rblzjb bclc dzqlq zll ndmz lgccp mpbsn lzxgf njdfc zjdkj mfnc rznmz nzhtc xbdh kqth plmpl bkqzk krh jsphx sbtz qlhqg pqhd cjf xrjzvh lgm szh nrbl dtvsk srhcd vgzjp mqmq szcgft rpjcjd bbgz ggqsr hgcb (contains fish, eggs)
 xbdh rpf zlcbnx mhvtp bxcgf jsphx dpls jrvxh zvtvzc bthckj vkjd tk mccpbg zdvcnx cjf bclc cmlh spcqmzfg lhslfpx kcmmj mkhbznt klcl bqcjvv qpngxk srhcd vrgk bmnqp sjxxzrd mkt mcgx ffgs cnnd zbhmgm nbrh ztv dzqlq bltzkxx nrbl dk bscmf jqrq fkszg sncl hgcb xrjzvh spql ggqsr pflk tfn jcpnmh (contains dairy, nuts, sesame)
 pflk dpls jvjmd sbtz hlk rbxnc mkpc hrmdt mkhbznt pxldx bltrbvz krh fxsrc qpzcmf cqzqvj nhsx blvlch ffgs ghvj pqhd bltzkxx nbrh dzqlq lhslfpx rgnz njdfc rtxfsp vxmfmjjh fpc pmht cftgsk jqrq frnz spql dpmcrh bhgpk hvlc vgh rpf bvskjzc zpcscz hpdn plmpl xdjhhj dsbj bthckj lzxgf ljsmz kjfnqg rghrrt xhlkscn rhjbx lgm bbhvzz nrbl qlhqg cdhfzl ttzd zxftz xbdh mflngx gtgkt rpjcjd ztv (contains eggs, fish, peanuts)
 bscmf rmngx bchbc kqth pqhd bbhvzz njdfc bltzkxx bnnqz fkszg rhjbx shkkk shptr nbrh cjf bltrbvz xbdh spcqmzfg zdznn tfn bhgpk vkjd bsql zxftz jqrq pflk qtxgzpx fpc zphlmnb dzqlq rtjk vpchddj smktk sbtz hhppz rtxfsp qmbxq zgfl tprdg zll lgccp mhlv cnnd jsphx bthckj kcmmj hlk tgfcl jrvxh qfkgx spql dk qpngxk ljsmz (contains wheat, dairy, peanuts)
 jpvrvr nbrh lvrp crsp xbdh shkkk jrvxh bqcjvv bvskjzc mpbsn pxldx bbgz txs rbxnc vrgk cnnd bltrbvz rghrrt lgm xrjzvh rznmz zpcscz srhcd hffzvrj spcqmzfg ngzp qpzcmf dsrxrt rpjcjd spql vdm lhslfpx bltzkxx pflk dpmcrh krh rrngl dpls tgfcl dzqlq xhlkscn ztrgb (contains wheat, sesame)
 bscmf dzqlq ggqsr czs bltrbvz bhgpk dk xrjzvh xbdh jgblz rtxfsp fzkxc cftgsk zdznn blvlch bltzkxx btpdk nqsdkrh ttzd spcqmzfg fpc qbrr kbzmtz sbtz mxpn bxxs dsrxrt pflk sncl hffzvrj mfqvks mfnc hzfd xdjhhj mhlv hpdn nrbl vdm zbhmgm qtxgzpx rtjk vpchddj vkjd lvrp spql zgfl mpbsn cjf ftkqfrv mccpbg qlv zvtvzc tprdg (contains shellfish, wheat)
 smktk xcq fpfdkl hcnmld qpngxk bxcgf hzfd pflk frnz zdvcnx zdznn dsbj tplp lgccp vgzjp mpbsn qpzcmf bltzkxx pqhd txs spql ksbr vkjd vdjjl njdfc fpc qgkhxq ccjjp dfk bxxs vdm rtjk qtxgzpx bltrbvz rblzjb tpvb xbdh lgm hvlc mqmq djp rbxnc cqzqvj rghrrt pxldx hhppz rpf cxhplp srhcd gbsvjgg pmht cfl dtvsk bclc hgcb dzqlq rbprd fzkxc xzzl bthckj dvrhz mcgx tfn mxpn ftkqfrv rhjbx shptr ztv dk krh jqrq ztrgb mcvjsk bnkgs nbrh nrbl cftgsk zjdkj zbhmgm hflzrt qlhqg tprdg (contains wheat)
 tk sbtz fpfdkl bnnqz tprdg btpdk xbdh jvjmd szcgft rzfcn ndmz bqrpdxt vrgk dsrxrt kqth sncl czs cftgsk lgm hrmdt rgnz mhsr hcnmld bxxs crsp dpmcrh lvrp zpkl bclc ftkqfrv rlcv hzr njdfc ttzd zgfl bltrbvz tplp hgcb rtjk ztv blvlch mfnc ffmgfz zpcscz zxftz srhcd pxldx kcmmj dvrhz bbgz rpf zphlmnb pflk hqnnsm ljsmrl ngx bxcgf mfqvks spql djp zjdkj cdhfzl vpchddj spcqmzfg sjxxzrd qbrr xrjzvh hhgqp bltzkxx (contains sesame, nuts)
 czstl bclc bltrbvz jqrq ztv cxhplp mpbsn bchbc dpmcrh rpf rhjbx hpdn ttzd hvlc rmngx bqcjvv tfn rbprd bkqzk cfl vzfg mkt bltzkxx xzzl zdvcnx pflk ztrgb krsl dzqlq zvtvzc nqsdkrh kcmmj bsql mflngx hzfd qlhqg krh mfnc sncl btpdk cdhfzl ftkqfrv hflzrt tplp xrjzvh sbtz ljsmz spcqmzfg xcq hffzvrj qpngxk mxpn gbsvjgg plmpl spql cjf rgnz hlk lhslfpx mfqvks ljsmrl rzfcn kjfnqg rlcv ffgs bnkgs (contains nuts, peanuts)
 hzfd ccjjp frnz dsrxrt krsl bltzkxx txs krh hgcb vgzjp qpngxk rpf bvskjzc jvjmd qlv sncl sbtz jrvxh bsql crscm bscmf rbxnc hqff djp srhcd vdm nbrh dzqlq lgccp bnnqz btpdk jsphx tplp nrbl qfkgx zdvcnx qbrr cftgsk pflk rmngx rblzjb mpbsn xbdh shkkk ksbr spql zjdkj xrjzvh nqsdkrh hlk bltrbvz rpjcjd rznmz vkjd jcpnmh bqrpdxt zxftz nhsx (contains sesame, eggs)
 rbprd frnz jpvrvr sbtz hcnmld spql rhjbx jzcrblh zphlmnb lgccp szcgft dvrhz dsbj qlhqg gbsvjgg dzqlq bltzkxx shptr bsql qpzcmf bbhvzz csdbg hvlc zgfl qbrr djp qpngxk pmht dfk spcqmzfg cftgsk nhsx lhslfpx kjfnqg zpcscz pflk zpkl bqrpdxt xbdh cdhfzl bhgpk lgm pxldx bscmf ztv jsphx lzxgf bxcgf dtvsk kcmmj gtgkt cjf tpvb rpf mflngx cfl nbrh btpdk czstl fzkxc (contains shellfish, wheat)
 spql rtjk xdjhhj fkszg dtvsk qpzcmf spcqmzfg cmlh pxldx hlk mhlv ffgs tgfcl jcpnmh hrmdt pqhd rpf vrgk bnnqz bvskjzc dzqlq mflngx bltrbvz zvtvzc xbdh ttzd klcl kcmmj hflzrt nrbl bscmf jgblz lvrp hzr mccpbg dsrxrt hcnmld vdjjl bmnqp jsphx hffzvrj vxmfmjjh nbrh pflk vkjd ndmz (contains shellfish, peanuts)
 mqmq fxsrc shkkk pflk rghrrt klcl gbsvjgg rpf ffgs rrngl bscmf nrbl ttzd pqhd tk rzfcn sbtz krh cjf bltzkxx rmngx szcgft mcvjsk cftgsk vzfg mccpbg vgzjp bqcjvv xbdh vdm zdznn hvlc dvrhz zlcbnx mhlv ggqsr rbxnc cdhfzl spql tplp ztv djp fzkxc hzr dzqlq sncl bgvng kjfnqg tvndt hqff ghvj xrjzvh dsbj fpc jcpnmh dsrxrt mkpc szh rblzjb bchbc jpvrvr bclc hhgqp tfn cnnd vrgk xcq hlk sjxxzrd dk spcqmzfg ljsmrl bhgpk qpngxk lhslfpx ccjjp fpfdkl cxhplp tgfcl (contains wheat, nuts)
 bkqzk dzqlq rpjcjd spcqmzfg kcmmj ngzp hpdn bthckj shptr qmbxq spql xzzl bbgz zphlmnb vdjjl czs cxhplp fzkxc sjxxzrd smktk zlcbnx mfnc nrbl vdm qlv crsp qbrr mkt srhcd mxpn qpngxk xbdh dpls dvrhz xrjzvh bltzkxx csdbg bmnqp mqmq zvtvzc gtgkt bltrbvz szh hhppz bxcgf pflk dsbj klcl mkhbznt vgh lzxgf ljsmz rlcv btpdk pqhd qfkgx mkpc hrmdt ccjjp tplp (contains fish, wheat, nuts)
 szcgft dfk ksbr zpkl ffmgfz mhvtp dzqlq rpf hgcb rgnz pmht ccjjp nb zgfl kjfnqg bltzkxx qmbxq bxxs mhlv rmngx spcqmzfg vkjd spql rtjk bthckj tplp zll nqsdkrh cfl xhlkscn pflk bgvng gbsvjgg vzfg krh hpdn xbdh bclc ljsmz pxldx lzxgf fpfdkl kcmmj zphlmnb crscm btpdk jrvxh ndmz mpbsn jcpnmh (contains fish)
 plmpl crscm bltzkxx rbprd nzhtc mcgx xdjhhj lgccp vrgk zphlmnb czs lhslfpx nqsdkrh ghvj shptr spcqmzfg mhlv bltrbvz jcpnmh rpf kjfnqg spql vgh sjxxzrd qlhqg qtxgzpx fxsrc mhvtp qbrr njdfc zgfl dpmcrh vxmfmjjh nrbl dzqlq xcq krh lgm dsbj cnnd jsphx mkhbznt mkpc vpchddj mcvjsk rzfcn zvtvzc cqzqvj bthckj gtgkt mxpn hhppz rghrrt nb xbdh mhsr cxhplp ffgs dpls qgkhxq qlv qfkgx vxkkgd ttzd szcgft tplp jgblz (contains shellfish, dairy)
 zbhmgm bgvng jcpnmh btpdk ksbr rpf txs nhsx dfk qmbxq zll bltzkxx rbxnc qlv ggqsr kbzmtz hzr czstl nbrh dvrhz pflk srhcd zdvcnx spcqmzfg shkkk hvlc cqzqvj rlcv crsp bthckj ztrgb fzkxc xhlkscn rtxfsp rznmz bnkgs tgfcl blvlch cmlh bltrbvz hcnmld vdjjl jpvrvr qpngxk xdjhhj ffmgfz xrjzvh cdhfzl ngzp shptr gtgkt njdfc mqmq cxhplp spql vrgk rghrrt dsbj krsl bbhvzz rgnz vgh ffgs ghvj mhsr tplp sncl ngx dzqlq cftgsk mcvjsk bbgz bvskjzc qtxgzpx hhppz mkhbznt cnnd (contains nuts, dairy, wheat)
 bclc djp jgblz shptr smktk tpvb mflngx bltzkxx jpvrvr hcnmld krsl bbgz rblzjb tk dzqlq qfkgx lgm tgfcl spql vxmfmjjh kjfnqg hhppz hpdn bnnqz xbdh jcpnmh ghvj jrvxh zdvcnx pqhd hqnnsm bltrbvz mcvjsk krh qlhqg cftgsk rmngx kbzmtz hlk rzfcn bxcgf fkszg gtgkt bsql hzfd ndmz bqrpdxt mxpn nzhtc bscmf ffmgfz nhsx spcqmzfg shkkk pflk nb rhjbx qgkhxq rznmz ftkqfrv kqth vzfg hzr txs gbsvjgg rtjk rbprd ngx ljsmrl zlcbnx xhlkscn zpkl qbrr (contains fish, wheat)
 mflngx rpf rblzjb qpngxk vgh hpdn mkhbznt ljsmrl jqrq qlhqg cnnd spcqmzfg zlcbnx lzxgf jrvxh gtgkt mhvtp mhlv jvjmd rrngl bnkgs zgfl ljsmz spql bqrpdxt xbdh qpzcmf tprdg ghvj pxldx xhlkscn pflk jgblz ztv pmht nzhtc mkpc ztrgb ngx tplp tgfcl zpcscz lvrp dtvsk bltrbvz mkt xrjzvh mccpbg bxxs hflzrt zxftz tpvb nb bbgz bxcgf jcpnmh ffmgfz bltzkxx hhgqp (contains peanuts, shellfish)
 mhlv qpngxk vkjd bnkgs rghrrt mxpn vpchddj gtgkt jzcrblh dsrxrt jgblz xbdh bltzkxx vdm bbgz mcvjsk gbsvjgg spql fxsrc zpcscz tpvb nbrh mfqvks hvlc zlcbnx nzhtc dpmcrh dvrhz shkkk rpf pflk bqcjvv cqzqvj shptr smktk mkpc crsp nrbl zpkl fkszg rpjcjd dzqlq hcnmld hflzrt mhvtp qbrr zgfl dk xdjhhj pmht szh ttzd mqmq rgnz bbhvzz dpls ffmgfz btpdk jcpnmh bltrbvz vzfg vxmfmjjh dtvsk zll cnnd qtxgzpx ndmz sncl ngzp dfk vxkkgd bthckj czs czstl (contains eggs)
 tvndt rpf spql vzfg nbrh zpcscz hrmdt bltzkxx spcqmzfg qtxgzpx mcgx dsbj rpjcjd bnnqz hzr vdm dzqlq kbzmtz zpkl jgblz klcl bltrbvz rznmz rbprd ljsmz njdfc ghvj dk lvrp gtgkt nb xzzl mqmq bscmf jpvrvr krsl rlcv mhvtp bsql ztrgb fzkxc bbhvzz ztv sbtz xbdh bhgpk mccpbg plmpl bkqzk mkpc mhsr xdjhhj fkszg rrngl zbhmgm ftkqfrv (contains fish)
 jgblz jsphx rlcv gbsvjgg dzqlq cmlh bqcjvv shkkk dtvsk klcl tplp bxxs qbrr rznmz spcqmzfg czstl zvtvzc rbxnc rpjcjd xbdh hgcb vgh qlhqg ffmgfz crsp ttzd tvndt gtgkt hlk mhvtp bmnqp rmngx mhsr vkjd kjfnqg ksbr zbhmgm mccpbg ztv bltrbvz kbzmtz rgnz bthckj rpf hflzrt qmbxq crscm kqth lgm pmht dsbj bnnqz blvlch spql pflk hzfd (contains sesame, fish)
 zphlmnb njdfc ggqsr bqrpdxt ftkqfrv zpkl lgccp ffgs smktk ccjjp spcqmzfg bkqzk hpdn rtjk xbdh sncl xcq zdznn hqff nhsx fpc jpvrvr cjf dfk hflzrt hlk pqhd mccpbg bltrbvz jzcrblh mhlv gtgkt xdjhhj rblzjb rghrrt zpcscz qbrr zvtvzc mkhbznt jvjmd ttzd mhvtp dsbj bltzkxx tgfcl ljsmrl kqth rbprd kcmmj hgcb blvlch pflk ffmgfz rmngx hzfd bbhvzz zgfl hqnnsm tvndt cqzqvj nqsdkrh spql tplp shptr krh tfn ztrgb crsp ghvj hzr rpf rhjbx kjfnqg (contains peanuts, dairy)
 blvlch mpbsn spcqmzfg smktk nbrh bchbc bxxs ghvj mfqvks qpzcmf pxldx ndmz qbrr qlv hffzvrj hrmdt ffgs nzhtc frnz vkjd csdbg kjfnqg rzfcn dtvsk jrvxh crsp rbprd krh qlhqg tprdg mkhbznt rhjbx tvndt jsphx nb shptr hzfd rpf dpmcrh mkt jgblz rghrrt zlcbnx bgvng hqnnsm pflk cdhfzl srhcd bltrbvz fpc zdvcnx xbdh dzqlq nrbl vrgk lhslfpx bmnqp bltzkxx hgcb dfk jpvrvr gbsvjgg czstl ffmgfz vzfg (contains wheat)
 bsql nzhtc tvndt dfk klcl zbhmgm cxhplp pflk vpchddj vdm tfn pxldx vzfg nhsx nqsdkrh ndmz gtgkt nrbl mqmq srhcd bqcjvv vkjd smktk qpzcmf tk cftgsk jrvxh hhgqp kbzmtz btpdk hrmdt bvskjzc qtxgzpx dvrhz crscm mhlv nb krh zpkl rrngl zlcbnx rpf dpls njdfc dzqlq bltrbvz spcqmzfg ftkqfrv xcq qbrr rbprd rzfcn dk ggqsr rlcv sbtz mcgx qmbxq spql fpfdkl hlk hflzrt xbdh fzkxc zll qgkhxq csdbg mhvtp shkkk szcgft (contains sesame, shellfish)
 bhgpk spql jzcrblh bltrbvz vxmfmjjh cnnd lgm spcqmzfg gtgkt pflk mpbsn dk vkjd vrgk bbgz tprdg bclc zvtvzc zpcscz rblzjb krh gbsvjgg bbhvzz qlhqg ksbr mqmq ccjjp bgvng hzr zlcbnx ndmz hqnnsm hrmdt lgccp blvlch rbxnc czs ljsmz qmbxq jvjmd zjdkj kbzmtz sncl nrbl rgnz bmnqp rrngl cfl rpf bxcgf nzhtc dvrhz tplp dzqlq dsrxrt jpvrvr ghvj hvlc vgh klcl zxftz bsql lvrp hzfd ttzd rghrrt qlv bnkgs rmngx dsbj xbdh pmht mkt xrjzvh hhppz shptr btpdk bqcjvv smktk ggqsr hgcb tk ljsmrl hflzrt tvndt bnnqz (contains shellfish, dairy)
 txs bqrpdxt fxsrc xdjhhj bnnqz bltrbvz fpc hhppz qpngxk spcqmzfg rbprd qgkhxq jcpnmh szcgft rpf hflzrt csdbg qlv czstl gtgkt zxftz lhslfpx fkszg zpkl ffgs ngx djp ztrgb rmngx bltzkxx spql lgm mfqvks vrgk mflngx tvndt dzqlq jvjmd jpvrvr zgfl smktk mcvjsk bthckj rtjk mpbsn bscmf xbdh qlhqg (contains shellfish, wheat)
 jsphx dpmcrh qmbxq jzcrblh bvskjzc zdvcnx fzkxc jrvxh xcq mkhbznt lgccp mkpc rpf dpls ngx dk bbgz gtgkt mccpbg qlhqg zpcscz csdbg sbtz vgh spql dzqlq ndmz jvjmd crscm hgcb qpngxk rbxnc qtxgzpx bhgpk zvtvzc szh djp mflngx vrgk jgblz njdfc hzfd nrbl bchbc sjxxzrd spcqmzfg vdm xbdh bltzkxx fkszg rblzjb rpjcjd hhppz cfl bthckj pmht cftgsk pxldx mcgx mfqvks bltrbvz xhlkscn hzr tfn (contains sesame, shellfish)
 vzfg bthckj blvlch rtjk bqrpdxt zvtvzc bvskjzc fpc zphlmnb nbrh zxftz xdjhhj csdbg cfl xbdh zdvcnx frnz zlcbnx mkhbznt xcq czs lzxgf mhsr spcqmzfg szcgft xhlkscn ggqsr tprdg cqzqvj qlv bsql mkpc qlhqg rpf bbhvzz dvrhz jzcrblh gtgkt mflngx bltrbvz nb bxxs klcl mqmq pqhd sncl ftkqfrv tfn hpdn qbrr spql ffmgfz bltzkxx dzqlq lhslfpx zbhmgm (contains eggs, fish)
 bbgz xdjhhj bclc vkjd szcgft rrngl mcgx sjxxzrd zpcscz rpjcjd jzcrblh tgfcl zjdkj hhppz dpls tvndt zlcbnx bqcjvv ngzp mhsr qpngxk mpbsn tfn ngx gbsvjgg lgm xcq xbdh cftgsk mkpc ztv njdfc rtjk bqrpdxt jqrq szh ttzd cqzqvj mhvtp dpmcrh qgkhxq klcl pflk spcqmzfg mflngx rmngx frnz cxhplp rzfcn lhslfpx hqnnsm hpdn hzfd hcnmld hffzvrj blvlch nrbl hgcb ztrgb mkt dzqlq fzkxc jgblz ffmgfz rhjbx vrgk xhlkscn rghrrt spql vgh vxmfmjjh jvjmd bltrbvz jcpnmh ggqsr qlv rlcv zdznn zll xzzl vxkkgd qmbxq hrmdt pxldx bkqzk rpf (contains eggs)
 nb dzqlq jvjmd bltrbvz sbtz hffzvrj lgm mfqvks vdm txs ffgs mqmq qpngxk hhgqp njdfc hrmdt mcgx qlv nrbl fkszg rzfcn bltzkxx dfk mhlv vgzjp spcqmzfg hqnnsm rpf tplp rpjcjd hhppz xbdh bbgz qgkhxq hflzrt blvlch mfnc bxxs hqff mxpn fzkxc cnnd nzhtc rghrrt kjfnqg qlhqg bbhvzz bnkgs tvndt bxcgf spql bmnqp hvlc xzzl (contains sesame, peanuts, eggs)
 ksbr kjfnqg mpbsn qmbxq qbrr qgkhxq gtgkt mcvjsk btpdk mkt dzqlq ggqsr rgnz kbzmtz rpf bsql tk hhppz zjdkj bltrbvz jpvrvr tprdg vgh hzfd szh szcgft hflzrt hlk rrngl bbhvzz gbsvjgg kqth bhgpk vzfg ljsmz jcpnmh mflngx bmnqp dsbj mcgx dsrxrt klcl rblzjb xbdh rpjcjd bqrpdxt mkhbznt frnz krh smktk hgcb jrvxh spcqmzfg dtvsk qlhqg dvrhz fzkxc rlcv txs zpkl cfl zdznn xhlkscn lhslfpx vxmfmjjh nqsdkrh rghrrt bltzkxx qpzcmf jgblz ccjjp pflk bclc mqmq shkkk dk (contains dairy, nuts)
 tk bqcjvv pflk mxpn rgnz rmngx vdjjl fpc vrgk ljsmz mfqvks vgh ffgs nhsx bchbc rpf zll dtvsk nqsdkrh vkjd czstl dzqlq hqnnsm zdvcnx bltzkxx hcnmld spcqmzfg srhcd sncl hgcb ngx rzfcn jcpnmh mqmq nbrh bbgz dk mflngx bltrbvz crscm ndmz spql qfkgx bgvng zpkl jrvxh mfnc zphlmnb zbhmgm sjxxzrd dvrhz ffmgfz hrmdt fzkxc jqrq cnnd szh (contains nuts, shellfish)
 bchbc zphlmnb frnz fzkxc xbdh zpkl btpdk csdbg zbhmgm nrbl qpzcmf rtjk mxpn cqzqvj hhgqp zpcscz bgvng mpbsn shptr hzfd vdm fkszg lvrp lzxgf bltzkxx dpmcrh nzhtc kbzmtz vxkkgd hflzrt kqth gtgkt ggqsr rghrrt bclc mfqvks dtvsk bltrbvz vgh tprdg zvtvzc txs pxldx bbhvzz sncl mhvtp kjfnqg hcnmld krh hzr blvlch qfkgx spcqmzfg qtxgzpx bqrpdxt krsl rbxnc dzqlq rpf pflk fxsrc zlcbnx bxcgf zdznn jgblz (contains fish)
--- a/21/main.py
+++ b/21/main.py
@ -0,0 +1,78 @@
 from dataclasses import dataclass
@dataclass
 class Food:
    ingredients: list[str]
    allergens: list[str]
 def parse_food(line: str) -> Food:
    delim = line.find(" (contains ")
    return Food(
        ingredients=line[:delim].split(" "),
        allergens=line[delim+11:-2].split(", ")
    )
 def read_input(filename: str) -> list[Food]:
    with open(filename, "r") as f:
        return list(parse_food(line) for line in f.readlines())
 def count_ingredient_occurences(foods: list[Food]) -> dict[str, int]:
    ingredient_counts = {}
    for food in foods:
        for ingredient in food.ingredients:
            ingredient_counts[ingredient] = ingredient_counts.get(ingredient, 0) + 1
    return ingredient_counts
 def get_allergen_map(foods: list[Food]) -> dict[str, set[str]]:
    allergen_map = {}
    for food in foods:
        for allergen in food.allergens:
            if allergen in allergen_map:
                allergen_map[allergen] = allergen_map[allergen]&set(food.ingredients)
            else:
                allergen_map[allergen] = set(food.ingredients)
    return allergen_map
 def part1(foods: list[Food]) -> int:
    allergen_map = get_allergen_map(foods)
    allergen_ingredients = set()
    for ingredients in allergen_map.values():
        allergen_ingredients.update(ingredients)
    count = 0
    ingredient_counts = count_ingredient_occurences(foods)
    for ingredient in ingredient_counts.keys():
        if ingredient not in allergen_ingredients:
            count += ingredient_counts[ingredient]
    return count
 def find_with_one_ingredient(allergen_map: dict[str, set[str]]) -> tuple[str, str]|None:
    for allergen, ingredients in allergen_map.items():
        if len(ingredients) == 1:
            # `min` is used just, because you can't use indexing on sets
            return (allergen, min(ingredients))
 def part2(foods: list[Food]) -> str:
    allergen_map = get_allergen_map(foods)
    allergens = []
    while True:
        pair = find_with_one_ingredient(allergen_map)
        if pair == None:
            break
        allergens.append(pair)
        allergen, ingredient = pair
        del allergen_map[allergen]
        for ingredients in allergen_map.values():
            if ingredient in ingredients:
                ingredients.remove(ingredient)
    allergens.sort(key=lambda p: p[0])
    return ",".join(a[1] for a in allergens)
 if __name__ == "__main__":
    foods = read_input("input.txt")
    print("part1: ", part1(foods))
    print("part2: ", part2(foods))
--- a/21/test.txt
+++ b/21/test.txt
@ -0,0 +1,4 @@
 mxmxvkd kfcds sqjhc nhms (contains dairy, fish)
 trh fvjkl sbzzf mxmxvkd (contains dairy)
 sqjhc fvjkl (contains soy)
 sqjhc mxmxvkd sbzzf (contains fish)
--- a/22/input.txt
+++ b/22/input.txt
@ -0,0 +1,53 @@
 Player 1:
 18
 19
 16
 11
 47
 38
 6
 27
 9
 22
 15
 42
 3
 4
 21
 41
 14
 8
 23
 30
 40
 13
 35
 46
 50
 Player 2:
 39
 1
 29
 20
 45
 43
 12
 2
 37
 33
 49
 32
 10
 26
 36
 17
 34
 44
 25
 28
 24
 5
 48
 31
 7
--- a/22/main.py
+++ b/22/main.py
@ -0,0 +1,68 @@
 def read_input(filename: str) -> tuple[list[int], list[int]]:
    with open(filename, "r") as f:
        player1, player2 = f.read().split("\n\n")
        player1_cards = list(int(l) for l in player1.splitlines()[1:])
        player2_cards = list(int(l) for l in player2.splitlines()[1:])
        return (player1_cards, player2_cards)
 def play_combat(player1: list[int], player2: list[int]) -> list[int]:
    while len(player1) > 0 and len(player2) > 0:
        card1 = player1.pop(0)
        card2 = player2.pop(0)
        if card1 > card2:
            player1.append(card1)
            player1.append(card2)
        else:
            player2.append(card2)
            player2.append(card1)
    return max(player1, player2)
 def play_recursive_combat(player1: list[int], player2: list[int]) -> tuple[list[int], bool]:
    seen_games = set()
    while len(player1) > 0 and len(player2) > 0:
        seen_game_value = (",".join(map(str, player1)), ",".join(map(str, player2)))
        if seen_game_value in seen_games:
            return player1, True
        seen_games.add(seen_game_value)
        card1 = player1.pop(0)
        card2 = player2.pop(0)
        player1_won = None
        if len(player1) >= card1 and len(player2) >= card2:
            _, player1_won = play_recursive_combat(player1[:card1], player2[:card2])
        else:
            player1_won = card1 > card2
        if player1_won:
            player1.append(card1)
            player1.append(card2)
        else:
            player2.append(card2)
            player2.append(card1)
    return max(player1, player2), len(player2) == 0
 def calculate_score(cards: list[int]) -> int:
    score = 0
    for i in range(len(cards)):
        score += cards[i] * (len(cards)-i)
    return score
 def part1(player1: list[int], player2: list[int]) -> int:
    winning_cards = play_combat(player1.copy(), player2.copy())
    return calculate_score(winning_cards)
 def part2(player1: list[int], player2: list[int]) -> int:
    winning_cards, _ = play_recursive_combat(player1.copy(), player2.copy())
    return calculate_score(winning_cards)
 if __name__ == "__main__":
    player1, player2 = read_input("input.txt")
    print("part1: ", part1(player1, player2))
    print("part2: ", part2(player1, player2))
--- a/22/test.txt
+++ b/22/test.txt
@ -0,0 +1,13 @@
 Player 1:
 9
 2
 6
 3
 1
 Player 2:
 5
 8
 4
 7
 10
--- a/23/input.txt
+++ b/23/input.txt
@ -0,0 +1 @@
 469217538
--- a/23/main.py
+++ b/23/main.py
@ -0,0 +1,102 @@
 def read_input(filename: str) -> list[int]:
    with open(filename, "r") as f:
        return list(int(c) for c in f.readline()[:-1])
 def take_cups(cups: list[int], start: int, length: int) -> list[int]:
    taken_cups = []
    index = start % len(cups)
    for _ in range(length):
        taken_cups.append(cups.pop(index))
        index = index % len(cups)
    return taken_cups
 def put_cups(cups: list[int], start: int, target: list[int]):
    index = start
    for value in target:
        cups.insert(index, value)
        index = index + 1
 def simulate(cups: list[int], moves: int):
    max_value = max(cups)
    min_value = min(cups)
    current_cup_label = cups[0]
    for _ in range(moves):
        # take 3 cups
        taken_cups = take_cups(cups, cups.index(current_cup_label)+1, 3)
        # determine destination cup
        destination_label = current_cup_label - 1
        while destination_label not in cups:
            destination_label -= 1
            if destination_label < min_value:
                destination_label = max_value
        destination = cups.index(destination_label)
        # put back the 3 taken cups
        put_cups(cups, destination + 1, taken_cups)
        # move current cup
        current_cup_label = cups[(cups.index(current_cup_label) + 1) % len(cups)]
 def simulate_lookup(next_cup_lookup: list[int], current_cup: int, moves: int):
    max_value = len(next_cup_lookup) - 1
    min_value = 1
    for _ in range(moves):
        # take 3 cups
        taken_cup1 = next_cup_lookup[current_cup]
        taken_cup2 = next_cup_lookup[taken_cup1]
        taken_cup3 = next_cup_lookup[taken_cup2]
        # determine destination cup
        destination = current_cup
        while True:
            destination -= 1
            if destination < min_value:
                destination = max_value
            if destination != taken_cup1 and destination != taken_cup2 and destination != taken_cup3:
                break
        # put back the 3 taken cups
        next_cup_lookup[current_cup] = next_cup_lookup[taken_cup3]
        after_destination = next_cup_lookup[destination]
        next_cup_lookup[taken_cup3] = after_destination
        next_cup_lookup[destination] = taken_cup1
        # move current cup
        current_cup = next_cup_lookup[current_cup]
 def part1(cups: list[int]) -> str:
    simulate(cups, 100)
    num1_index = cups.index(1)
    return "".join(map(str, cups[num1_index+1:])) + "".join(map(str, cups[:num1_index]))
 def part2(cups: list[int]) -> int:
    # create lookup table for the next value
    next_cup_lookup: list[int] = [0]*(len(cups)+1)
    max_value = max(cups)
    cups.append(max_value+1)
    for i in range(len(cups)-1):
        cup = cups[i]
        next_cup = cups[i+1]
        next_cup_lookup[cup] = next_cup
    for next_cup in range(max_value+2, 1_000_000+1):
        next_cup_lookup.append(next_cup)
    next_cup_lookup.append(cups[0])
    # perform the simulation
    simulate_lookup(next_cup_lookup, cups[0], 10_000_000)
    # calculate the final result
    star1 = next_cup_lookup[1]
    star2 = next_cup_lookup[star1]
    return star1 * star2
 if __name__ == "__main__":
    cups = read_input("input.txt")
    print("part1: ", part1(cups.copy()))
    print("part2: ", part2(cups.copy()))
--- a/23/test.txt
+++ b/23/test.txt
@ -0,0 +1 @@
 389125467
--- a/24/input.txt
+++ b/24/input.txt
@ -0,0 +1,471 @@
 neswsesewswswswswswneeswswswswwwnwsw
 nenesenenwneenwnwweneswnenenenwnw
 wewnesesweswsenwnwnwsww
 eeneswneewneseneeeseeweeesenwe
 nwnenenenenenewnwnesenwnwnenenenenenwnese
 nwwenwswwnwwwenwnwwnwnwwwnwnwsew
 nwnwnenwnwnwnwnwnwswnwnenwswnwnwnenenwne
 swsesenweseswseseswswnwswswswseesesesw
 nweneneswnenenenenwnenwnwswswnwnwwswsenwne
 wnwnwenwnwnwnwnwsewnwnenwnwwwsw
 senwewwsewswswnwseswsenwswswsewnenww
 nenwnesenwnenwnwnwnenwenwswnwnewnwswnw
 neneswwsesenwsesewnenenenenenewenwne
 weneneeneneneneeene
 ewnwsenwwwwnwnewwneswnwsenwwnwsesww
 neenwnwnenenenwwnwnwnenenenenwswnwnenwnwe
 wwnwswwwnwwnwwwwwwnewnw
 neneneneeneneneneneneswnenenenenenenene
 nwwnenwnenwnenenenenesenenwnenenwnwnwne
 nenenwsenwsesesenwwnwneenesewnenwnene
 nenenewneneeneneneneeseneswnenenenwnene
 seseenwewseswsese
 seseeseseseseswsesesesesesesesenesesese
 sewswswnwswswswswwew
 wseswnwnwnwnenewnwnwwnwwnwnwnewnwsw
 neeeenenwneeeeeeswneneneeneee
 swnwnwnwnwnwnenenwnwewnwnwnenenwnwneenwne
 swswsweswseeswseswneswwswseswnwsesww
 swnewwnewwweewwwwnwsewwwww
 eneswswwewwwswswesewwswswnwwe
 eswnweeeeeneeeeeeesweeee
 wswswnweswwswnewswseswswswswswswswe
 nwewnwwwwnwwwwneswswwwwwnew
 nwnwnwnwnwwnwnwwenwnwnwnwsenwnwnwswnwnw
 swswnewswswswswwswswwwwweseswswswnww
 swneewswswswwswnwnwswwnwwsenwswese
 nenenenwswnenenwnenenwnwnwnenenwnenenwne
 nwnwnwnwwneswswenwenwenwnwnwnww
 neneseswnenwneneneneneenesw
 nweswswnwsewswnwwseeseneswnwneene
 wwwwswwwnwswwwswsewewwswwsw
 wewswwewswswswnweswwswswsweswwsw
 sesesesesesewseswsesesesesesenesenesesw
 wsweeneeeeneeeene
 eseeeeeeeeeeeenweseseseee
 wesesewswnesewneeswseewsewnwesesw
 seweeneneeweeeneneeeneneeseew
 wswseswswwenwswwwswwwsw
 eweweeewseneswseenweswnweswene
 wwswwwwwwwsewnewswwwwswwww
 swseewseneeneswswnewneesewsenwese
 sewwwwwwwnwwwnwwww
 seseneeseseeenwsesweseeeseswsesesese
 neenewnwneneeeneseneneeneseeneneene
 nwenwwwswnwwwwwnw
 nwseswseseswneseeswneswswneswswsewswse
 swswswwswwswwswnewwswwswwseswswe
 wnwwnwwnwnwsenwnwnwwnww
 swswnwseseseswsesesesewenesewenwsese
 eseseesenweeseswseseenwee
 nenwseseneeeeeenweseenweweee
 swsweseswnwswswswswswswseswswswneseswsw
 wnewenesenesweswwnwwseesesesee
 wsesesesewseneseseesesesesesesesesesese
 seeseeseeeseeswsweesesenwneenwnw
 nwwnwnwnwsenwnwwswnwnwsenweswnwnwnwnwnee
 esenenenenenenenenenewnewnenenenenene
 eswswswswswwswswswwnwswswswswswwswsw
 nwnenwnwenwesenwsewsenwwsewswnwsenw
 nwnwnwwnwnwnwwnewwwnenwsenwnwwnwwsw
 weeseswwenwnwwewwwwnwseenesw
 wwswswswwswwwnwwwswsewswwsw
 ewsewweswwwewwwwwwnwenwnw
 eenwnwnewneweneswseenewseswwsesw
 neenenenenenenewwneneseneneneeneene
 seswnwswswseswswnwnwseseseeswseswswseswsesw
 seseneswseewsesweseseseseseswnwsesesese
 nwnwnwnwnwwnwnwnwnwnwenwnwwnwnwwnwnw
 seswswsenwwseneseseseswswneseswnesesesesese
 eseeseeeeeenweenwesweneenee
 nwneswnwnwnwnwnwswneeseswenwswnwnwnww
 swsesweswseswswnwswswswswswswnweswswsw
 neseseesweseeeseeesewneeewsene
 neneswnewneneswseswneswnenw
 seweeweswwwnenesewwwnwnewsew
 swwweswswswwswswwswswnwswswwswswsw
 wneneenenesenewsenenwneswnewneenenw
 senwnewnwnwnwnwnwnwwnwswwenwsesenwnwne
 wwwwwwnwswsewwwwwwwsw
 neneweneeeeenenweneeeeeenwsese
 swswsweswswswswswswswswnwseseswswseseswsw
 swswswswseswswnwswswseswswnwswneswsee
 nwewnenwseneneswsenenenewnenwnesenwnenw
 eseswnwswswseneswseseswswseeswswswwsw
 seseeeseseseweneeseeeesesesesesese
 eewnweswswsweeenenwwnwse
 wwswwwswwsewwswnwenwnwswswwwesw
 wwewwwwwwwswwwnewwwwww
 nwenwwnwnwnwnwneseswnwnwnwnwnwnwnene
 nwwnewnwnwwnwnwnwwnwnwsenwwwnwnwww
 sewswneswseeswseneseswswswsewneseswnw
 newneswswwwwsweswswenesesewneswsw
 nwnewwwwwnwswwseswwwwnwwseese
 wwwwnewwwwwwenewswwwwwsww
 eseeeeeewseneswswseweeneesesee
 nwnwnwswnenwnewnwenwnwnwsenwenenwnwwnwne
 swseswseswsenesewswseseswswswseswsesese
 swswsesesesweswnesesesewsese
 eeweeeeseseeesee
 swnwnwnwnenwnwnwnwnwnwnwnwnwnwwnwsenenw
 nwwnwwwnwswwwwwwnwwewwewww
 swnenenenenenenenenenenenenenenenenene
 swswneswswswswswseswswnwswswswswswewsw
 nwneswnwnenwnwnwnenwnenenenenwnwnenwnwenw
 nwnwnwnenwnwnwnenwnwnwnwnenwsenwnwnwnwwnw
 wnwnwwnwswwwsenwnwnwnwnwwnewseeww
 nwenwnwnwenwnwwnwnwwsenwnwswwwnwnwnw
 eeweeseseeeseseeseseseseseese
 neeenesewswsweeneenweesenenwswesw
 nwwnwnwnwewwnwnwnwwnwwnwnwnwewnwnw
 wnwneswwwswwwewwwwswwsewwswne
 nwnwsesenenwnenwswseswnenwwnwnenwnwnwnene
 nenenwnwnewnwswnwnwnenwneneneeneenww
 wwnwswnwnwnwnwnwswswsenwnwenwneesee
 nenwnwnwnwnenenwnenwnesenenenenenwnwsenw
 swseswswseswseseseswneseswswswseswswswsw
 swswsweneswnwwsweswswswswswswswnesw
 wnwwwwwwwwswwwewnewwnwwwwse
 nwnenenenenenwnwnwwnwenwnwwsenesesenwnw
 nenwneeeeeswswneeeeeneeeneswnee
 nenwnwnwnwnwnwsenwwnwnwnwwnwnwnwsenesenw
 nwnwwnwwswwwnwwnwwnwsewwnwnewnw
 wnwwwwenwseswnwswewnww
 ewwnwwwswwnwwnww
 nwnenwnenenenenenenenewnesenene
 sesesesweenwsenwenwsenweesenwenwnw
 neneeeeswenwneeswsenwenenenenenenee
 seeesenwswwesenwsesenwseseswesenesee
 nenwnwnenwswnenwnwsenwnesenwnwnwnwnenenw
 eeeeeeeeeeesweenwswne
 esesweswnwsenweeesesesenweeesww
 eseseeseseseseseweeseeeseesee
 swnenenenwnwnesenenewnwneeneneneenenesw
 neneneenenenenewneneneseneneneneeewse
 wnwnwnwnwenwnwwewswwwwwnwsewwwe
 neneeneneneneneneneneneswne
 seswswseseeswswnwseseneswswseseseseswsese
 wswnwswweneweenwwswswneswswwseswne
 eswwwswswneswwswwnwwwenwwwswsewsw
 wswswswswenwnwnwswswswswswswseswneeswe
 wwwwwswswwwenenwnwnwwnenwsesww
 wseweeenwnewneneneneseeneneenwswse
 senwwnenwnwnewseswwwsewswnewneene
 nenwnwnweneneenesesweneneneneneneswsw
 swseswswswswwswswswneseswseswsewswswnesesw
 enewnenwnenenenwsenenwnwnwnenenwseswene
 wwnewwwswwwwwwwwwswsewwww
 wsenwnwnewnwnwnwnwnwnwnwnwnwnwnwwnwnw
 wenwnwwwwnwwsenwneswsewwsewnwnw
 neenewneneeeneeee
 neseswnwswswnwnwseseswseewseseneseswseswsw
 nenenewwnenenewneeenenenweswsene
 seeeeesesesweeenweesenwseeseswe
 swesenweseewseeseeswswesenwenenewne
 seseseseseseeeswnwswne
 wwwwwwwwwwnwnwsewnwwwwsewe
 nenwnwneeswnwnwenwswswnwnwnwswnwnwnwnwnwnw
 swswswesewswswseswswswseswswseswswsw
 neneenenenenenenenenenewnenenenenenene
 wneseenenwnwwswseswswwnewnwwwww
 nwnwnwwnwnwweseneswwnwseenwnwnwwnwsw
 nwnwsenwnwnenwnwnwnwsenwnwnwnwsenwnwnewnwnw
 wsewneeneneneneneneeeneswe
 nenwnwnweweswneswne
 eseeeeeseeeeeeeeeweewee
 newnwswnenwneneneneeneweswnenwnee
 wwnwwwwwwnwwnwnwnwsewnwwwww
 wwnwwnwwnwswwnwwwwnwwwnweww
 neseseseseseswsesesesesesesesesesesesesw
 nenwnwnwnwswwnwwnwnwwnwswnwnwnwwnwnwe
 neenweeeeeeeeeeneeswseeeswe
 swswswswwswswnwswswsesweswswnwswwsw
 wnwsenwwnwwnwnwnwnwnwnenwnwnwnwnwnwnw
 seswnwswenesesewneswnwsewsesesenenesw
 eneewnweseswweeenee
 neeneswneswsweswwnenweee
 eeseesenewneeeneneswenewne
 swnwsewnwnwneweswnenwneneseesenwwsesw
 wseewswwnenwswswseesweseneswnwswese
 seseseseseswsesesewswseseswseseseseswnene
 seseswsesesewnenewseneswnesew
 wswseswnwwwwewwwwwswwwwswww
 nwnwwnwnwnwnwnwnwnwnwwnwnwnwnwnwenwe
 nenwsesenenenenenwnwnwnenwsenenwnwnenwnewne
 nwnenenwnenwnwswnewnwnwenenwnwnwnwnene
 neseswswnwnwnwneswsweneseseswswnwnewesw
 swwsewwwewswswnwwswswwnwsw
 neweeswneeeneeneneenwswneseewnw
 sewswwweseenwneesewwsewswneee
 wwwnwnwswwwwwwnenwnwnwnwnwnwwnw
 wwwswwwwwwwwnewwwwneswwsew
 nwseswswswneswenesewseeswswswswswnenw
 enwswseeeseseswesesesesesenesenwseese
 nenenwneswnwnwneneenwnwnweswnenwnwnwnwnw
 nwswweneeeeeeeeeeneeeswnese
 sweseseseseeeswenwneeeeese
 seswswseeswsesewesweswswsesesesenwnwsesw
 eenwnewesesewseneeswseewsweenwe
 seseswnwwwnewwswweswnwwnewwesw
 eeeeeeseseseeseweeeeeeseenew
 weseeneswenwewe
 swswsesenwseswseseswseneesewswsesesesese
 seswseseswswswseseswswswneswswswsesesw
 swwswwsewswwswnwwsesweswnwsenwnwnee
 eneweeneneneeeeeeee
 sesesesenesewsesese
 nwnwnenwnewnenwnwnwsenenwnenwnwnwnwnwne
 swneswseseswswnwseseseseseswwseswswsese
 swswsewnewswwswswswswnenwwwneswsewsw
 nwswswsweneseseswseneswseseswnweswew
 swseswswswseswswswswseseswseswnesesw
 nenwnenenwenwnwnwnwnenenwwwenwnenwne
 swwnwnwwwwnwewwnwnwnwnwnwwnw
 esenwneswnenwneeswwswenwseneseeenw
 eeeswsenwweneenenenesenenewsenenesew
 wwswsenwwwnewwewwswwswwwwne
 wswesweenewswswnwswsweswnwnwswswe
 swswseneswswswswsewswsw
 wnenenenewneenesenwwseeneneswne
 seeseseseeseenweewseseneseseeseese
 seseesesewseseseseseesweseneseesese
 swnwnwneseswswswswwe
 senwnwnwnwnwnwswnwwnwnenenwwnwnwnwwnww
 wwwsenwewwswswwnwsewwewswsww
 swwswswswneseseseswsewseswswneswswsesw
 seseeeseseseeseseseseseesewesesese
 seseeeseweeneseewseeeeeseee
 nesenwnwnenenenenwnwnwnwnwnwnenenwsenw
 seseseeesesesenweseseeswseseseenese
 swswswswswswswseswswswswswswswnenwswswswsw
 senwwswwswswwswswwswswswneswsweswsw
 swesenwswseswnwnwseseswseswswsweseesesw
 wwswswwwswwweswwswswwswswwswsw
 swewsweswswewnwwnewewwsewnwswww
 wnewseseswswnwswwnwnwwnwswseswseeew
 swsenwseseswswseneswswseseseswseseseswsw
 swswwwewswswswwwweswwwwesww
 swswswneeswnwswswswswswweswswswswswnwsw
 enweneeseeneneswswsewneneneeeene
 wswwswnwwwewwnwswesewswseenwe
 sesesesweeeseeewsenwseseeeseeee
 swswswswnwswswswswswswswsweswswseswswswsw
 seseewseseeseesesesesesesesesenwsese
 eweeseweeneeeeneeeeeeeeese
 eeeeeeeeeeeeeeenweeeesw
 nwswswswwwwwwwswswweswwwswswsw
 weswswnwswweswnwnwneswsenesewwenesw
 enweeseeseeneseseseewseeseeesesee
 nwnwnwnwnenwwnwnwnwnwsesenwnwwwnwnwe
 seseseeneseeseseeseeseeseeeweese
 sesesweeswseswsenweswseswnwsenwswswsw
 sesweseeeeeeenwseswnewse
 swwnwwnewwwwwwnwwwwwnwnwww
 swswswneswswswswswswwswwwswwswwesw
 wnewneneweneeneseswsenewnesweneene
 eseeeseeeseenesw
 sesenwseneseseseseswswswsesesewsesesesesw
 nwneneneneswnenwnwnenenwneenenwnwnenwnene
 neneenewnenenenenenenesweeeeeesee
 nenwwswnwenwnwnwsesenenww
 eenweswsweeeeneeneeweneene
 nenewwneseenwnenwnwsenwnenwwnw
 wwwnenewwsenesenwnwsewewwswswswnew
 seswwswneswswswwnwswwswwswswswwswwsw
 ewneneeeeenweesweswenweneneene
 sweswsenwswswwswnewnenewswenweenw
 sweweseesesesesewsenwseeweenesenwse
 swnwnwwwwwwwne
 nwnwswswseswswswswwswswswswswswse
 seswseseswswseseseeseswnwswsenweswseneswse
 eeswnweseeneeeeseewseseseseesesee
 swswswswswswseswwswsweswswneswswwnenw
 wnwenwwwwnwwwwwnwwnwwww
 swwswwswswswswswwswwnwswswswswswswse
 nwwwwwswnwwnwwnwwwwnwnwneww
 eeneswenwnwswnwsweswswnwswnenenwnwse
 swswseswswseswswswswneswswseneswseswswse
 neeeeeeeeeeneneweweeeene
 nwnwneenwnwnwnwswneswnenesenwswewnww
 weswwswswnesewsewswswwneneseeese
 wswswswseswswnesesesw
 enwneswwnenwnewnenwnweenwnenwneswnesene
 eswwswswswswswwswswswwswswswnweswswsw
 eswsenweswswnwswswswswsewswwwnwswswsw
 nenwnenenenenwnenenewneenenenenwnenene
 wnesesenewwwsewwwnwnwwnenwwswnewsw
 wwswswwswwswswwswswwnwswseswswswsw
 neneneneneswnenwnenenenwnwswnenwswnenee
 sesesesenesesenesewsesenewseswsesesese
 wneewseswwwnewswswswswenwnewwww
 swwnwswswswswnwswswswwsesweswswwesw
 seseswseswseseswseswnweseseseseswseswse
 swswseseswswswswsesweswnwseeseswnwsese
 neswswnwnwsewnwenwwnwwweenwsewnw
 ewneeneneenesweneeeneeenenenene
 nwnwwnenwnwwnwnwnwsewnw
 eeneneeseenweseswneesweneenenenw
 neneneneeneneeneswnwnwneswnenenenenenenwne
 nwneneswsewswnwsewwnenwewnw
 nenwsenenwnenenenwnesenenenenenenenenwse
 seeeesesenwseeesesewsewseeseese
 nenenenenenenesesewnenwnenenenwnwnwnenw
 neeneneeewneeneneneneeneenenenee
 wswnwswseewnwnweneewwneww
 seseenwseweswnwneenenenenwnwseeneswse
 seswsenwswseeseseswswswseswswseswsesenwsw
 neseeseswseswsesewswswnwswwseswnenwsesw
 nwnenwswnenenwnwnwnwnwsenwnw
 nwnwwswnwwenwnwwnewnwnwnwwnwnwsenwnw
 seseeswseenwnwseneseeeesesewswsesese
 neneswnwenwnenenenenenenwnenwnwnwnwnwnesw
 swswswseeswneswswswswswsweswwneswswswnw
 swseswswswswswswneeswwswwswswswseswsesw
 sesesesewnwseseseseseseseeseseseseswsese
 neenenwwenwswnwneswsweenwnw
 wwnwwwnwwnwwnwnwnwseenwwnwnwnwnwnw
 swneswsesweswswswswswswswswwwswwsw
 esweeneeneeeneenesweeee
 eeeeeenweesweeeeeeweew
 seseswswewseswwseeswenwnwswseswswse
 nenesesesweswnenwewseewnwseswewne
 eseweseseseseeesesesesesesesesesee
 sesenwswseeswswsesesesenwseseseeneseese
 swnwswswnwnwsenwneenwwnwnenwwneenwe
 nwwwwnwnwnwnwnwwnwnwnwswewwwnwwnw
 seseswsewesesewseseseseseseeseswsesese
 senwswwnwnenweesewswenenwneneswswwne
 eseweneswsesewwnwwseseswswnesenesew
 swwswswswswseswswswswsweswswsw
 eesenweweseseeeeeeeseeseseese
 seeeeneenewweeene
 nenwswswseeewsewwnwwnwwwswwsenw
 swswswswwwnewwswnwwnewwewewsww
 sewwswswneeswwnwswwwswnewswwswswsw
 swwewwnwswswswnwnwweswneeeeww
 swswwswswseeseswneeweswswnwnwswene
 newwnwseesewsesenwsewseewesenwene
 wswwwnwwsenwwnewwnwsewwnwwne
 swswseseswnweswnwneeswneswsesesenwwswnesw
 nwnwnwnwwnwnwnwsenwnwwnwsenwnwnwwnenwnw
 nwswwenwswsweswwswswwseswswswnwsesw
 nwewwwnwwsenwwwnwesw
 wnwnwnwnwnwwnwsenwnwneswnwenwwsenwnw
 swnenwnwwnwnenwnenenwnenwnwenwnwenwnwsw
 swswnwswsweswwseswnwwswswnwsenwswew
 eeeeneeswseeeeeeeeeenenwene
 neeeneneneeeneeeeneswneneenenee
 nwnwnwwnwnwneenwnwnwnwsenenwnwnwnwnwnw
 eeeseeeswseenwenenwseeseeeesw
 neeneneeesenweeeene
 neneenenenesenenenenenenenenenenenenwne
 senwwswswwswswsewneseeseswneswswswswene
 neeeeneeeseseeeeseeseeseesesww
 eeeneneenewneneseneneneeeeneee
 swnwwnwsenenwnenwnwsenwnwnenewnwenwne
 neneneneneenenenenwnenenwwsenenenenenenw
 wwnewwwseswwnewww
 nwenesenwnwnwnwnew
 swseseswseswseswswswenwswswseswseneswse
 senwswsweseneeeeneeneeswnesewswwnw
 eenenwswswnwswewwneenwwwwsewsenw
 seeeenenwneneeneeeneeswe
 newenweeneswneneswne
 swswswseswswsenewwnwwwnwnesweswwww
 nwneneeeneswneneneneeneeneeneeene
 eeeeeeesweeeeewnweseeenw
 swseswswswswswsewneswnwswswsesesesesesese
 nwnwsenenenwswnwnenenwwsenenwnenewseswse
 wsewswwswwwswwnewseenenenewwwse
 nwnewnenenenenenwnenenenenenenwnenwsenw
 wnwwwsenewwnwwwwwwwwwwww
 nenwnenewseeseeswswenwwsesewsw
 enwnenesweneneneneswenenwswneneeenenene
 seeeeeenwnweeseeseeswseseeeee
 wwnwwnwswwwwnwwnenesww
 seswswswneseseseseswseseseswsesesesewswse
 wnenwseseeseswswwseseswswswswseswswseswsw
 wnwnwnwneenesenwnwnwnwnwnwnw
 nenenenwneeneneneneneneswnenwnenenenenwne
 sewwswswswwswswwswwswnwseswwswneswsw
 eeeneeeswsenwwseseeeeeeeseese
 swswswswswswneswswswswswwswswswsw
 newswwswwnenwsewwwwwwwwwswsew
 sesesesenwseseseseseseeseseswsenwsesese
 swswsesweswwseswwswnwswswswswswwnwnw
 nenenwneneswnenwsenewnesesewnwnewnee
 sesesesesewneseseseneseseseseseseswsesee
 nenenenenwwnesesenenenesesenewneenwene
 wnwwwwsewnwswneenwwenwswwwwww
 swseswswnwswswseswswswnwswswseseeswswswswsw
 wnwwnwwnwwwnewwwnwwswwwwwsewe
 neeeeneneenenenesewneneeneeenene
 seneenweeneeeeeneenweeeeseee
 enewnenwsenenwnenenenenesenwnenenwnenenw
 neeneneswneneweenwneneeneeenenee
 wwwswwswsweswneswswwswsewswswww
 swwwswswseswwwswswwsenenwswwwwnw
 neenwneneneeseswswewnwswnenwnenenwnenwne
 seeseewwweeseweseeseeesesenwe
 swneneneneneneneneneneneeneneneneenene
 wwswseesweswneenenwnwseesewswnwene
 seseseswseswswseswseneseseswswseswsesesew
 neeneneseenewenenwswnweeneeswneswne
 seswwneswsewnwnewsenwswswenwww
 wwsewwwwwwwnewswwewwwwwww
 nenenenwnenenenenenwnesenenenenenenenene
 eseswswswwnwswneswneseeswswswswswswswww
 neeesweenewenenweneneewnenenenene
 nwswwwnwwewswwswwwswseswwwwswswsw
 wwenwnwewswwwnenwwwnewnwswww
 nwneenenwswwwsewewwsesewwsewswnw
 seswseneswseeenenwseeseswneswsesesesenw
 eeseswweseeseseesesesesenw
 neseseseewwwneseseenwseseeseseeee
 seswnwsweseseeswseseswnwnwsesesenweseswe
 neseseswswswswsesesw
 nenenenewnenwnwnesenenenenwnenwwneneenene
 sweseseeswsesenweseesesewsesenwenesee
 senenenenwwnwwnesenenesenenwnwnwnewnwe
 swwnwseneswseseseneseseneseswnwnesewwswse
 wnwnwnewnwnwwnwnwnwwsenwswwnwnenwwww
 wnewwwnwwwwwsewwwwwwwnwwnw
 eeesenwenesenweenwesweneeeeee
 wsesenewnenenenenw
 eeeeeseneeweneeeeeeeeee
 eneseneweneneeeeswneeneeneneww
 nwnwnwnwnwnwnwenwnwnwwewnwnw
 seseseswswseseseswsesesewseseseseseswne
 swwwsweswswswswwswswswswswneww
 seeenweseweseesesweeeeeenwe
 nweneneeneeeeeeeeneseeeneene
 wswnewwwwwwwwswswwwswewwww
 swswswseswswswwseseswneswseswseseswswsesw
 swswswswseswswswsenwnweswswswseswsewesw
 nwswnwwnwswnwnwnenwnwenenwsenwne
 nwwnwesenwnwnwnenwwwnwnwewnwnwnwnwswnw
 wswswswnwwwwwneswwswwsewwswwsw
 nenewneneneeneewnenenenenenenwnenenene
 nwseseswswseseseeeseeseneseseseseese
 eswseeseseeewnwseeseseeeseseesese
 nenwnwnwneneeneneneneneneneneneneneswnw
 nwnenwneneneneenwnenenenenenenwnewnene
 nwneneenenenwseeseneeneeenenenewnene
 wneseswsweswswsenwswswswsweeswnwswnw
 swneeswsewswswenweneswnwnesewew
 nwnwnwnwnwnenwnwnwnwsenwsenwwnwnwnwnwnwne
 neswneswnewneswseseswnwnwswnewseswsee
 eenenwseweeneeneneeweneweeene
 nenwwwnwnwneenenenwswnwnwswseenwswnwenw
 sweswnwswsweeswwswnenw
 wsewsewsenwneswnwnwwewswnwweenw
 nenwnenwswnwnenwnwnenenwnenwnenwnenenene
 swwneswwewwswneswwwswswwswwwse
 swsewswwsewwswneswswwseneswswswnesw
 seenenwsweesenwseswnweseeeeenwe
 swwswwswswswweswnwsweswswswswnenwwwsw
 wnwnwwswenwweswenwwwwwnwnwswnw
 swswwswwwswwwwsewwwwwswswwnesw
 neswswswswswswswwswswswswwswswswwwe
 wenwenwwseswwwnewnwseseswwneswneww
 nwswswswneswswwwsewwswswswswswsesww
--- a/24/main.py
+++ b/24/main.py
@ -0,0 +1,91 @@
 from typing import Iterable
 STEP_LOOKUP = {
    "e":  ( 1,  0),
    "w":  (-1,  0),
    "ne": ( 1,  1),
    "sw": (-1, -1),
    "nw": ( 0,  1),
    "se": ( 0, -1),
 }
 def read_input(filename: str) -> list[list[str]]:
    tiles = []
    with open(filename, "r") as f:
        for line in f.readlines():
            line = line.strip()
            steps = []
            i = 0
            while i < len(line):
                if line[i] == "e" or line[i] == "w":
                    steps.append(line[i])
                else:
                    steps.append(line[i:i+2])
                    i += 1
                i += 1
            tiles.append(steps)
    return tiles
 def get_black_tiles(tiles: list[list[str]]) -> set[tuple[int, int]]:
    black_tiles = set()
    for steps in tiles:
        x = 0
        y = 0
        for step in steps:
            dx, dy = STEP_LOOKUP[step]
            x += dx
            y += dy
        if (x, y) in black_tiles:
            black_tiles.remove((x, y))
        else:
            black_tiles.add((x, y))
    return black_tiles
 def part1(tiles: list[list[str]]) -> int:
    return len(get_black_tiles(tiles))
 def get_neighbors(tile: tuple[int, int]) -> Iterable[tuple[int, int]]:
    for offset in STEP_LOOKUP.values():
        neighbor = (tile[0]+offset[0], tile[1]+offset[1])
        yield neighbor
 def count_neighbors(tiles: set[tuple[int, int]], tile: tuple[int, int]) -> int:
    count = 0
    for neighbor in get_neighbors(tile):
        if neighbor in tiles:
            count += 1
    return count
 def simulate(black_tiles: set[tuple[int, int]]) -> set[tuple[int, int]]:
    white_tiles = set()
    for tile in black_tiles:
        for neighbor in get_neighbors(tile):
            if neighbor not in black_tiles:
                white_tiles.add(neighbor)
    new_black_tiles = set()
    # Any black tile with zero or more than 2 black tiles immediately adjacent to it is flipped to white.
    for black_tile in black_tiles:
        black_count = count_neighbors(black_tiles, black_tile)
        if black_count == 1 or black_count == 2:
            new_black_tiles.add(black_tile)
    # Any white tile with exactly 2 black tiles immediately adjacent to it is flipped to black.
    for white_tile in white_tiles:
        if count_neighbors(black_tiles, white_tile) == 2:
            new_black_tiles.add(white_tile)
    return new_black_tiles
 def part2(tiles: list[list[str]]) -> int:
    black_tiles = get_black_tiles(tiles)
    for _ in range(100):
        black_tiles = simulate(black_tiles)
    return len(black_tiles)
 if __name__ == "__main__":
    tiles = read_input("input.txt")
    print("part1: ", part1(tiles))
    print("part2: ", part2(tiles))
--- a/24/test.txt
+++ b/24/test.txt
@ -0,0 +1,20 @@
 sesenwnenenewseeswwswswwnenewsewsw
 neeenesenwnwwswnenewnwwsewnenwseswesw
 seswneswswsenwwnwse
 nwnwneseeswswnenewneswwnewseswneseene
 swweswneswnenwsewnwneneseenw
 eesenwseswswnenwswnwnwsewwnwsene
 sewnenenenesenwsewnenwwwse
 wenwwweseeeweswwwnwwe
 wsweesenenewnwwnwsenewsenwwsesesenwne
 neeswseenwwswnwswswnw
 nenwswwsewswnenenewsenwsenwnesesenew
 enewnwewneswsewnwswenweswnenwsenwsw
 sweneswneswneneenwnewenewwneswswnese
 swwesenesewenwneswnwwneseswwne
 enesenwswwswneneswsenwnewswseenwsese
 wnwnesenesenenwwnenwsewesewsesesew
 nenewswnwewswnenesenwnesewesw
 eneswnwswnwsenenwnwnwwseeswneewsenese
 neswnwewnwnwseenwseesewsenwsweewe
 wseweeenwnesenwwwswnew
--- a/25/input.txt
+++ b/25/input.txt
@ -0,0 +1,2 @@
 2069194
 16426071
--- a/25/main.py
+++ b/25/main.py
@ -0,0 +1,30 @@
 def read_input(filename: str) -> tuple[int, int]:
    with open(filename, "r") as f:
        cards_pub, doors_pub = f.read().splitlines()
        return int(cards_pub), int(doors_pub)
 def reverse_loop_size(public_key: int, subject_number: int) -> int:
    key = 1
    loop_size = 0
    while key != public_key:
        loop_size += 1
        key *= subject_number
        key %= 20201227
    return loop_size
 def transform_key(subject_number: int, loop_size: int) -> int:
    key = 1
    for _ in range(loop_size):
        key *= subject_number
        key %= 20201227
    return key
 def part1(cards_pub: int, doors_pub: int) -> int:
    subject_number = 7
    card_loop_size = reverse_loop_size(cards_pub, subject_number)
    return transform_key(doors_pub, card_loop_size)
 if __name__ == "__main__":
    cards_pub, doors_pub = read_input("input.txt")
    print("part1: ", part1(cards_pub, doors_pub))
--- a/25/test.txt
+++ b/25/test.txt
@ -0,0 +1,2 @@
 5764801
 17807724
Author	SHA1	Message	Date
Rokas Puzonas	c065f3c6c6	feat: solve day 25	2022-05-22 20:22:21 +00:00
Rokas Puzonas	e8aad99eca	feat: solve day 24	2022-05-22 18:39:45 +00:00
Rokas Puzonas	da96bf0fb9	feat: solve day 23 part 2	2022-05-22 15:22:22 +00:00
Rokas Puzonas	ad19c6c3f0	feat: solve day 23 part 1	2022-05-22 14:28:46 +00:00
Rokas Puzonas	2a24eabe3f	feat: solve day 22	2022-05-22 13:23:01 +00:00
Rokas Puzonas	b57cadd08f	feat: solve day 21	2022-05-22 10:38:50 +00:00
Rokas Puzonas	46e6fa1852	feat: solve day 20 part 2!!!	2022-05-19 16:38:12 +00:00
Rokas Puzonas	ec25382f66	feat: solve day 20 part 1	2022-05-19 15:19:28 +00:00
Rokas Puzonas	4f1e08a310	feat: solve day 19	2022-05-13 21:04:41 +00:00
Rokas Puzonas	2341d34270	feat: solve day 18	2022-05-09 01:04:13 +00:00
		`@ -0,0 +1 @@`
							`(9 + (5 + 2 + 2 * 4) * (7 + 7 * 5 * 3) + 7) + 2 + 4 * 2 + 3 * (8 + 5)`
		`@ -0,0 +1,53 @@`
							`Player 1:`
							`18`
							`19`
							`16`
							`11`
							`47`
							`38`
							`6`
							`27`
							`9`
							`22`
							`15`
							`42`
							`3`
							`4`
							`21`
							`41`
							`14`
							`8`
							`23`
							`30`
							`40`
							`13`
							`35`
							`46`
							`50`

							`Player 2:`
							`39`
							`1`
							`29`
							`20`
							`45`
							`43`
							`12`
							`2`
							`37`
							`33`
							`49`
							`32`
							`10`
							`26`
							`36`
							`17`
							`34`
							`44`
							`25`
							`28`
							`24`
							`5`
							`48`
							`31`
							`7`
		`@ -0,0 +1,13 @@`
							`Player 1:`
							`9`
							`2`
							`6`
							`3`
							`1`

							`Player 2:`
							`5`
							`8`
							`4`
							`7`
							`10`