y2024d16p2 not done

Cargo.lock

@@ -11,6 +11,31 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
 [[package]]
 name = "either"
 version = "1.13.0"
@@ -42,6 +67,26 @@ version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "regex"
 version = "1.11.1"
@@ -129,6 +174,7 @@ name = "y2024"
 version = "0.1.0"
 dependencies = [
  "itertools",
+ "rayon",
  "regex",
  "utils",
 ]

Cargo.toml

@@ -23,3 +23,4 @@ utils = { path = "../utils" }
 itertools = "0.13.0"
 regex = "1.11.1"
 md5 = "0.7.0"
+rayon = "1.10"

y2024/Cargo.toml

@@ -7,3 +7,4 @@ edition = "2021"
 regex = "1.11.1"
 utils = { workspace = true }
 itertools = { workspace = true }
+rayon = { workspace = true }

y2024/resources/19_input.txt

@@ -0,0 +1,402 @@
+rbrr, gbgrgrg, rgurwgb, grb, ggg, grbugw, brwggrw, rbbrub, grguuu, uuub, uw, urug, bru, wwrrb, rbwbb, urw, uwuw, ubg, uugug, wbub, guubr, rru, gwb, wggrg, gubbwww, wrr, wbw, grug, brrr, rgw, urg, gugg, rugwuwb, rwu, rgu, bbu, ubb, gr, wwwggw, ub, uggrb, bbwrru, wuwrww, gbrbwru, uubu, bub, uguub, b, uwgu, brggrr, rruuggrr, buuu, brbgw, wbugb, rbwru, wrgu, bbg, uwbg, ruwg, bgugub, urwrrb, bggugw, bg, rgrrb, guwwu, gbbr, rwb, urrgu, brw, gbrwg, gbgwwrb, grgb, ggug, ugw, wbwwbug, wrbru, uwww, wwuw, wubg, burubw, gwr, wwubu, ubggrr, uru, www, wwr, uwbw, ww, rbbrwbr, rrwgru, gwuwgug, wubwww, gwbbwwb, bwu, ubr, rrguwr, bu, g, wrwbr, ggwb, wbr, uubwbrrg, gubrurwu, ugbg, wrurwbwr, buu, wuwbgrbw, ruw, wwgrw, bbbr, wbg, grrrrbu, wguuggwb, wrrwr, rbrru, bur, wurgwbgw, wgr, burggw, grugug, uugbrg, bgurgrr, urbw, gurur, wggb, rrub, uwgwg, grrug, uuu, gurg, ugugg, rurb, bbb, rrggwwb, brwbb, rrbub, ugb, wwbgg, gbguw, wgwgbb, wgw, brrw, ugbwrg, wgub, uub, bwgrugwb, guwgg, gurw, rrruwr, wgg, bgw, wrub, bubrw, uwrbb, uubugbwg, bwr, ugg, gwrbg, gbg, rbuwr, gububbu, bbw, wggw, rwrww, bbggbr, urgburg, rwbgr, rgr, wbugu, uug, uwg, ubgruurb, r, uu, rrw, uuwgu, gbu, urb, ugwg, bgrgrrg, rub, wubgwbg, brgubr, uuuburb, rbrwgr, wgwur, wbu, buurrgw, uwu, wbgb, rgru, wgggg, gubbr, uubwwg, uurbbggg, bgrwg, wggburr, ubwrg, wu, urbu, wbwrur, urgu, bggub, gbuwbb, uruu, gwwggwu, wugubrbr, bgrb, rgrbrb, guw, brr, rbguu, bgb, rug, gbur, gbb, rbrwbbb, ruuw, wrug, bbrwbgu, wwuwwbr, bgugur, rgg, brbw, wru, burrg, gu, ggwuww, wuw, uurg, wuwwbrwr, bbgbr, wb, ug, rrru, gwbg, ubwrug, rgur, rwg, ggrr, rgbub, uwubub, rwugg, wgbw, wburr, rgbu, ugr, ggwwb, gg, bbrbwgrw, gwu, brgwrwb, bguw, bbwwurr, ruu, ggbbu, ggr, bgwbgr, gru, gguuw, rbg, urbb, grw, wrwubbg, wbuu, ubwuw, gug, rbbr, wwb, buw, gw, buuw, wurgbuu, u, uuw, rwbw, wbbguw, bww, urguuwr, buwb, rugguggb, wwub, wrgubb, wrbr, gubbrw, guugr, ubbu, rwwbrb, bw, uwur, uugugw, bb, grr, wwuu, grrggg, rur, burugrr, ggb, rr, grg, brgw, wbwgu, uruwb, wuu, bwwgwrb, urgg, rrwuru, wurbur, uwb, bwrb, wur, ruwbwug, gb, bbr, uuwguu, ggwgwggw, bgurbb, wrw, rrbu, ubu, wbrgr, ruug, rbrg, rbr, bubwb, wbwgbwb, urugww, wrgbw, wgb, grub, gwrbuu, rbb, rrb, wbb, gguw, ggurrwg, bgwg, uuurw, wrwuww, brg, gbuub, uuur, rwrwu, wgu, rrrw, rbw, bwrbr, gwrgwu, ubbruu, rurrbrg, wwbwb, ubrg, wbbb, brb, rgwgr, gwg, brrgb, rwub, guwburb, buwgbru, ugbug, bwb, wgbwuu, wrbg, rrwugb, guuub, burw, brgwbwb, ubrub, ggbb, wggww, buwwwwuw, gur, ugu, guu, gwrbbrug, wbggu, gbgbuu, gbr, ggub, bbwg, ugwuur, grgr, ubguu, urgw, ru, bgg, wwu, buggg, gbuu, uuwu, rrww, ugrw, urr, rbu, bbugb, rgb, uwrbbu, wrwguu, rw, wwwu, gbbbuguw, wbrwwg, gbbrwrwr, wugw, rrbb, wurg, wgbubg, wug, wwwwg, br, rwbg, ur, rrrggg, gbw, ggu, bwrwb, rrr, rguuww, wuwbgww, bug, wgwru, wgbggw, uww, bwg, ggw, ubw, rrg, wg, uur, uwr, wrb, bwurbg, ugur, rb, gww, ubuu, burr, ggwg, rwr, gwuww, bgbwu, gub, bgu, wwgr, wwgb, bbrug
+
+wwugguwgrwwbrwubrwrwburubgrwubbbrugbggwrbwrwwrgggg
+brwwgggrrubuwubbgbgruwgwguguwgwwugrgbwbgrbbwwuwwruug
+gruurgurbugwgwbwuwubrggrgbgguurgrugbuubwgwrguwggwburrrgu
+ugbrrgrwgbuggrrwuwwwbwugwwgbbrbuugbwbwbrrggwgruurrguuguw
+grgggbwuuggwbbugrburbbbbbbbgwubbruuggubbgrggurg
+wrggrurwbubuwwbrbrrurgrrrbuggwgbbgbbwgbwbbrgugruug
+ugrrrrwggbbuuubrbggrgurggruurgrburbrgubrwrwgbwwwuugbwwuw
+ggwrrwwrbbrrbwrgrwuurrbbwubgugruurbrggrrbr
+rrurruguurburuwubwugurrrwgwgubbbwuurbggrwruuwg
+gwbgrrggwbgbwrgwurbubgrwubwrgbugurbrbbrbrb
+rwburrrbrwggbgwbruuwrwrrurwwuwwbugguwwrurwbwrrbu
+uwruuuuwrwrwrrgurrubuwgwgrwbwuubgrwrbugubbbbuwbr
+rwwggwwurwwrrrbwrwwwugbrggruwgruggwbwwgguuuuwurbrgbu
+rwgbgwbgburuwubrbgrwrwubrrbrgubbwrgwbrbrugbbubbwurgu
+ugbbbubgbbuwbwrwgbgbggurbggrwbgubbwuwbbrwgrubbg
+wwbwbrggbrburubwgrwgbgrgwuruwrwwrgubwgurrbwrrwurwuurgggwgg
+wuwgbwrbbgguwgwurgwbrgbwguwrbwuugubuubuuwgbwrr
+ruuwuugwuuggbbwbuurguuwwgbwbgbgwbwwgwwuugugbbwwwruwuubrrgw
+wwbgrburbbwurgruwugbrgggrgwwggbbgwgurbbgubugbgwubwg
+wrggbbruuwrrbgrbwbuuubrruwgrwrrrgrwgwbbw
+rgbugwrgwwurbgwubwruwwbrwggbwruubwbbrrwubrgwurrrrugbgg
+buurwgrwgwbbugwgbuwbwurbwbggrugbbbwwbwrbwgrwurwubrgbrbbgu
+rwwururugbgubrwubrrggbwwbgbrgrrbbuurbugwbgwuurgbuubrgu
+bwgwruwwrbwgrgggrgwbruguwrubbrrgugbrbruwbug
+bwwrurburbbwbuubrrwwuwubwrburrwuggrbbuwwggb
+gbwuuuruuwguuwwbuwguuuuwgwuuugubbggrbuuuwb
+uuwrwrwwbrubgbrrwbrbuuuwrrggbrrgwuugbuurrbbu
+wubggwugrugbubgrbwwgbburbuuuwwbbwuuguggruugbuwwwbwrwbww
+gggwbuwrugwruurgubrugrrrubbwwguwurbwbrgbwgwwgug
+wrgguwwbbgbggubbuugbgrrbrurwuguwguuggwbwwrggww
+ubrruwrbuuggwuuwbrwgbguurbwbbgrrwurbbbgrwbubgwubgbrwgbbrb
+ugrgrwbrgwgwrrwbrwwugrruwrgrgwrurbbgurrbwwrruruwbbbrbrugu
+wbrgrubuugggruwwrwbuwgwgurugurbbgwwuggbwgrugwubr
+uugwugbububwrrgwwrrguruwwgwgbgugwgbrrwgrubbrwrrrbgwr
+rgwuugbwbwurggurrbrbuwggwwbbgwrbbrugwbggwggwuurg
+wgrrrurwgrgbwuwrggrbbgwgurugruwwugbuuruurub
+buwgubbgbwwgbwwrrggwwrrbwgwwgrugbbguwwwwgbwuwuuuururgur
+rburrbgwwwwgrrurbruwwbwbbwrwgubguwbbubwbgguruggruuugubbwu
+grbgurbbgguubrrwbrwwgrwrwwubbubbbugwwgurwgwgrbwww
+wrgbggrgrwggwuuwbrgwurgurrbwbbwrbgwuurwgrgw
+gbwwubwgrwuguwggbgrgrwwgugbuuwbuuwruwwgbbb
+ugrwwrrgwrguwgbbrbguugbbgbgbbbggbrubbbbrbguwwgu
+guggrgugguuubwwgruwwuggbugwbwwwururgbwwwrggrgbugubgubg
+rrgwrbggggbgwgggubrugrrbgrwwwuggbwwrgurwwuubgwrww
+bgbuuwgwgrgwwggrggrbwurguuururwrbbwuuwbwgugbbgwr
+bgbbrbgbrugrggrbwgurbgwwbbrurguwrbrwwwwwbbggrwbgrwwwbw
+ruwbbgburgrbrbwrrbwwwuwggguruubbbrugbgbbrurbugrubgwgur
+ubrgguggrwgrbrgrrbwrrrgrgbrruwgwrurugbgubb
+wuggrwwgrgwwwbgwwuubrggwuuwbubgbrgbuwurubbwbuwwbw
+grwbwruuggubgurrbrrwguggbwrubwwuuubbbgggwururw
+guurbugubbwbgrruggubbgrurgggwugugrrubgbruububgubgubu
+uubwwbgrurgrrurwbgwgwurguuuwguuwbwbuurbrgrgbuubgwbwbbgbbw
+wrggguwwwwrgbbgrwrbwbgbbuguurrgbbubwbbwrbgwuwwruubrwrrgbgu
+wgwugwwrrurbgwwrgbggbgbwgbbgrgrbuwgwrwrrurw
+bbbwbbgwgurrgbuugwbbrubrgrrggurwgguwruwruggrwwrgrrgbugrub
+bbwbrbrwrwbgurgrrwrrwbbrwrwgruugwbwrwurbwbwug
+wwgwrrrgbbgguwguuggwbrruubgwrwuuuwrgbrburbu
+urgwwgwbwbgrguwguubggwuwrbuugggbwuburubbuburrgbuwb
+wrgbbwuruubwuuguubwuguwwgbuurgrgwguwbrbwwrgrggugbbbb
+uuuubuuguubugbruwwwbrbrbgrrwwurwrruwwbuuwwrbbgrurbubbubrb
+bgwurgbwrbwurgwbgwburgubuuubbbwbwwwuuwrgwugg
+wrggwubugrugugubbguwgwbrwruurrggwuwwrbbgbbbrgbb
+wruwwgbbrrgwrgrggbrugrwwwbrbwubuggugwbwuggbrwgburbwbbwubbg
+ugwuuugbwwwrurrgubbbwguurbwgwbrgrwbwugugubbug
+wrgrubuuwrgrbwbuuubgrbubbrbgrurbuuwggbgrwwgwwbwr
+uururwwbrgwwrwggwbwrrrrgbbbuugbguwuwwggrgug
+ugrwbwwrgbrbwwuuwuuurbgruwgrugbrrrbguuwubbub
+wwwbrruggbuwwgbubwggrrgugruuurrurrwgwrguwwwrrgubugww
+wrgrrgbrbggbwbubrwbrwrwbbgbwuwgbbwggwrrubgurbugguwuwuw
+grrwbggrwbuugrggwubrbguuwrurbuuwbggbgugburbrrbuwwrrggggwwu
+uubrruwgwuwbggbbuurwubwgburbuuwugbwuwurrwbrbgrbbr
+rubuubuwuuburbbbwgbrrguwgrbbrwwgbugrubbruwgrgbgrbw
+rwwwbwwguwrurbubwrurrbuurbwrubuwruggbguubgwrbugguuubrgrg
+buwuwruubbrrrwbbuwbbugrwbguuwrubwrbwwrrgugwuur
+wrrbuwuwwgwrgwgrruwrwbbwbwwruuwwuugbgrggubbbwwgb
+guwbwrwuruwrgwuguguwbuwurruwbuggwuwrwwubugb
+bgbuwwgrrwwuwrbgrgbwbrggubwwbggwwbbwwurgbuubrrwwrburwgrbb
+wwwgbrbwrwrurrgrbgwbbgrbuwwbbugwwwuwwrurbu
+wrgbrurguwgrruuggrrugurwuurrubuuguwgugurwgbrruburuu
+wuwurubwugubrbrbwgrwbuugwbbbrwggrbwwguwwrbrbr
+wrgwrggbwbwbwubrbgruurbbgggububbbgbburgurrgruwb
+bggwbbrwbgugbgrwwgbbrruuguuuruuuwgrrrrgwbr
+wrgwwrgrgbwugbgwgbgbbgrgbuwwwwuwwbubbbwg
+gggbrrgwbwbuwbrbbbrbbwuubrrwuuggurwggwrwbwbu
+rbugwwuwrbwbguwbgbgrwbwbbggwruwbuwrwwubrgbbrwurwwwb
+bwwwbuggbuurbbuwrwwrbgubwbuurbrbubwgwgugrwuwgburwbbwwbrg
+wrggrgwgbgrwubgbwgrugwbuggggurrrwbrgwwwgwwggwgu
+ggburrrgubrrgwgwgbrwugwgwgrwbbbuguwbgbrwbuuurwrbr
+urrgbwwuubwwubuurrbwwgubuuggrguwwwgbwwuguwgbugb
+buugbwgwrurbbugbrugggwrbrwwruurgurwrburgrguur
+bwugruuggubrbuuwurbbwbbruggrwwbrruugrwrguw
+wrgwubgubbuwubwruuruuuwwrurrbgrrbruuurgrbrwugbbuggww
+ugubburbrggubgrwgwguburwwburbubbrubrwrbuwb
+wrgguwubbrrwbrwuwwbrwruubwgwwwrwwgbrrwguubbwwwugugwr
+wgwuwwgrwrubrgwrgubrggggwuwrgrwwbwwbggrgbuwu
+grwbwgubgwrggwrbgrwbuugrgrburbuubbgrwwwbwgb
+bwwwbbrbwwurruuwwggrwbggrgguwrubbwbgbbgugubwbbuug
+bbggwubbgwwrbburwwwgwrbwrbgrbubbwrrrgbgbruu
+wrgwurrubgguggwgrrbugbbwbrbuurgbbrwrwrwgugwubbbubu
+wrggggwrbbrugbrubguwuggubwggugrbuurwubgbuwubwgwgugugwubwbrwu
+bwwugbwbgrrbgrrbbrbgggbwwwwggbbrbwwbbbuwgguugubrububgwwu
+ugurgbgruurwbwgrruuwwbgbrrbbbggggurruruwrubbbuu
+uwrugrrgrwbrgubrwwuwwgwgrbbgrbgbrwwuwubuwr
+ggbgwbrwuwgruwrwgrrrrwugwgbrbbuwuwwbuubwgw
+wrrrgguurbgubbgbguwruugwrbrgwbgwrrbbuwugbbrwgrbbugrgbbgwuu
+urguruuggubbwurrubuurgbgbrbgugwwrrggwwwugugg
+gugbggubuwubrgubwuwrwbgbrgbguggwrbrrgwguugu
+buwurubbbwurgrubgwgggrruwrrbbrbugggggwbwwgwwb
+wrwbbuburwrrwwururbrwgbbrbgwbbrrrbubbgrgbuggwrw
+ugubruguuwrgwububrbgrbwgbwburwgurwbuwwubuwu
+gwrgugrbgbubbwubgbrwbuwggugwurrburgwrwrugubwggwuu
+rgbrgrbggwbwuubburrurggwggguurwuwwwrwuwurbrggrgbuwrgbgwbgb
+wrggrwwbrrurbbuuwburubgruurbrgwrwgrrgrbguguuubwug
+rguwwuuwgwwubwbggbugwgrrwgbrgbgurbwgrgugurrgguggrrbuuu
+ruwubrwugurgrbruruggwbugbgrurwuuwbwrwugwgrr
+wrgbrrbgubgbgwrbwgwubuggurguburgwrruruur
+uburbrrbgbrrruwruwgwrrgrgurgrruugrruwuuugbuwburwubbrbbgw
+wrbwuggbuuwwwuuwbwuuwgwbuubuwgrggrrbgbuwgubrruuggrrruuuwub
+rwwgbrrurubuwrgwgrbgbrrbbbwbbbwrugwbubugwuwgwugwwurwgrbr
+wrrgwrggrbuuruggggwrguwbwgrubgwbguuggbgrwrgubrurwuggrwgwrb
+wwrggguurbuwbwurwwbbwwbrggwggbrbbrgugurbrbwwwrbrrggbbb
+ubbrrbbwwrugugwrggwuwwuruwuwbwguwgggwwbwrbgbwuugruw
+rggbrwgbbgwrwwrrbgwbuwwbrbrbururwgbugwwbrguuruwrbbbbwrwgu
+rguwbuwgwrrbgwbwwwuwrrbrwwwburrbbwbruwggugubbu
+rgwbgwwbugbgwruugwwrugwrrbuwgrbbwbuwubguubwbugugrwu
+ubwwgrurugbrbrgwrbgrbwruwrbwwbugrwgwrwubrgbwwrurb
+rurugbugrwuwbgrbwgbbrguwgbgugwgurbbrbuuurbwuuwwgbgg
+rruubwwwuwrrwgwugwrbgwbuugbrbwugrwwuwurguw
+wrgwwrgugrbrruurwuwgbwguwurrubwbbwurwwrgruwbgbwwrwu
+bgruuwgwrgwugrrguwugwbrbgbbbgguurwrbubgwrr
+gwrgrwurbruwgburrruuggbuwbgbwggwgurubwgurrbwuwb
+bwbugugubgubrwubrbgruwrubbrurggbgrrgubrrbuurwrrubbwurbbb
+bggwwgrbburbbubbuuburuguwubrubgbrubrrrgwwbgrrggrgggwrrgrg
+rrrgbgwbgrwuwgubbwbwgubbrgwwbwburbwguuruwwwrbrb
+wrgwbbugggruwgbwrggbbburbrgbwuuwurbugggbuggrwrbw
+wgurbubuuwrwubrrgrrbrbwrwurwbrbgrggguggwubgrgbr
+rubgwgbwbrubrbbrwwbbrrugrbbrrwuugggggwrwugbbbrb
+wrwwubrbguubrggurwrburgggruwubggwgwbrgrggrggwuubwggubgggww
+wrgwbgbrgugggburuguuwgrrrbrgrwbgubruwrwugbggubuwbbbbwwwbw
+wrgrwggbwwrgbwubrubbwbbuuggrbbugrrrbguwbrub
+grbrwgbugbgwgwbwubbuurgrgbbggwgbgbwwwrurguuubgbrwugb
+urwbbbuggwugrgggurbuwgrrwwbuubwubugbgburgwgbubwuurwuwbuw
+wwgubbuwubrgrgwguwbgrurbgwwuwbgwwgbuuuwwwwggwgrrwwwwrbrbuw
+wurwrbgrubrrbguwwwgrggwwgrgbbbbuburgruwugwrbr
+gbwgbrbrrrggrurrbrrwwrrbwwgubgwwuruwurgrrbbrwb
+gubuwgggwgwwwwuwgggwgwwugrwbggbbwbwrrwugrwuurggwbgbgrwruug
+uwrugrgbburwwbugrbwwwbbgurruwbburgrwwwgrwrwrggg
+brbgrggwububuugrwgubwubbbwwgggrgurrwwggbburgbuugw
+ggwwbgugwwggrrububbgrrrrwwbwwuuurbuuubbgwbwu
+bgruubgwurbuwrrggugwwbwrbwbgwrwugugbrwwwbburugbbguur
+bbbrggbgrrbrubugbrguwrrrruwbuwbgugwubgrugrwruugwgbuw
+wuurgrrwurwggwwguguwwurwwugguuguubbuuruwubg
+bbuuwrbwwwgggrgrrrrbgwwbwurrurubgubwburgbggrwrubgwbrw
+rwuwwbrguggwuwrruwurubguubgwburrwgugrwubwwbwgwwbbbrgrbb
+gguuggrrggbwbubgrbrrwbbubuwbrwrwgbuggbbbuuuuuwrgrrgw
+bubbrwwgbwrwwggubgwwwubgbrwubuuruuwuwgwwgruggbw
+wubburwgbbgruuubwggwurwrubwuwbrgbuuwbbguwwgrwbugbwrrgubrg
+rbwrruguuuwwbrwwwbwrwrbubwuggwurrbugwubuggrbubwrubwbwu
+uggubuwbuurrbgrugwwubwubrrburubbbgbugubrwwbuwrbu
+ubbgbbgrbuguwwbgrwwwgwubuguubruugbguuuwbrrg
+rugbbrguuruuruwgbuwrwbbubgrrbrwwbwugrwugbwuuwbwwbbwuwrg
+gbubbuubburgrbbrgubggrbbwwuwwbbrurguubgwubbubbbuu
+uggwrwuubrrwrrwurbrwrguurrugwwgruwrgwrrrbbuubgrruruwr
+wrgrwburgbugwgruburwguurbgggbgubrurwurguwwurwwrbrubbwbwr
+bbrubwwbubwuwgwgbrbwuurwrrbgguwbwbgbwuwurbbwbrgrrgwbbgw
+bwurwgwgguubrgwbguugrubbrgwrugubbgwwubruguwbrbwb
+wrgrwggurrrgwwggbgwrgrrubuubwbwrrrwggbbgbgrbwgwbgb
+wubrrwbbugrrrrbbgrbwuwwggggrrbbbwurrbuurwbuwrwgrbggu
+gwgurwruwwbbgbrurrrbrurrrgrrggbgubwbggugrwrrbuw
+wrgwwwurubgbrgwbuguubwuwurbuurwrruuggrwrrburuuur
+gubwbwuggbbguwwbgbgrgggbwggbrrrrwubwrrrruuwbgrrwguww
+wrgguwubgwwwrwwbrbgrruwbrurrrugwrrbbrgbgbw
+guwwwgrrurrwuwbwrgububgwurrbrrbgbrrwguwrrggguuugbrbbwrgw
+rwwbggrrugburbbrbguwbgwwrubwrrwwbbgurruurbggruubrgggg
+uwbgbugwrguuwurgrrgrbrwwubrrbuuwggwwwurgurgwrgrwbr
+wwgrggwgwbgrugwrggbbruurbgbbwrgruuwbbrurwb
+urbwbgwbbugbuwwrgwwwwgbbwbruwbwgwwrrrrbubrbbgurbgwuru
+wgrgrrwububgruwubgwuuwbubbgurruruwrubgrgwg
+wbbbgbbbguuuubruurugwbruwbbrbwubrgrburrrrwrrb
+wrggrugrubgrwrwgugugrrgguuwrubwwugrrbuwbw
+uwbbggrrburubbgwwrwgggwgwggwgbuwbwgburbgrrwr
+wubbgrggwrrbrbrgwrbubbruugbrwbbbugbrgguubgrgwggu
+ruuuuurgrrrrrugbbrgburubbwuugwwgbgubgubwubguuururgrwb
+bwgrugbbwbbrrwuuuruwubgwuwbrwurrrbwgurwbur
+ubgwubrburgrgrwwrrurrgguwbbwbrbwbuuuuwwwugbrwgrwguubwbrrrg
+wbrbwruwbbubbgbbgurbuurbwrggbwbgrugugwwgwwwbrburbgbbwr
+ubgbbbbgwrwgrgrguubrrgugbgugubrwbruguwbwrugwuburwwbb
+ubrwbuubwuubrrbbrurgbwubuwwbrbrruwwrgrguwrrbwgrugwbubw
+gwwruuuwurbwrwrubrwwrrbwrrggrburbgwgruwubrrwgubbbuw
+rwggugubbwgwrwbwrwrwrgwgugugguruwgwbbrwbwrggwurb
+ugubuwurgrrgugbugrrwrguwwrrurubrbrbrurbrbbwbbuuwugrg
+uuurwubugubbggwwwurbwgrgruubrwbwgguwrwwrbubbgrgrbbgubb
+wggruwbwbrwgrwrwbrbuwbrbbwrwwrbubwggrbuwuggbbrgwrgbggwwb
+wrgbgrbrgwbggbgbrwgrbbwgrgbgrubbwgbrwrwwgbbbwurgwbgwbwbrug
+urgwwbwbbrwugruuruuubgbwubgwbuwbbggwrbrggwurgrrrgbububwg
+wguubbbbgwuuuwrrguurgugrrubrguurwggburbgrwbgwuu
+uurrbwuwwuwugbgrbgwbggwbwgwbwugbbwgurubwgrrbb
+wrwrbuggbbrrwrgugrububuwggbwrbrrbbruuuggwb
+wgwwurrwuuuubuuggrgwwuurrugruwbuwgwrrrwrwbwrubugrwwuwurbgw
+wrgruubububrbwggggbbrrgrbuuuuwrgwggruwurgggwgwggwuwwwgrwgb
+ruuggwgbrwwbubuggwwugrrubuwurbgrugrwgwubgbggrbbgbwgrurwggg
+bggbrgwrwruuuuuwbbrgbrgwubbubugbguugggwwrrugrbu
+wuuwguubwwguubbwggwwwurbgbugbwwwugwwguuugrwgrwrbwbrbubbgbg
+ggrgwbwrubrwugwrgbrwurwggrguurgurwrwrrgubbbwrwg
+wrgguwwrbubgrurgwbbuwguwuwgwbwugruruwwuuuwrbrubwrgr
+bgwrrbwugrbuggrwbuwrrbrrggggruuugbrrguwubur
+wrgwbgwruwggbwuubrugbgrrwubrgbburwwrbrwrwwrbguwgur
+buwbrgrbubgubgugwrrbwbgguuwbbwuubrgrrwwgubbbgwgggugbru
+gurbrrwbbwgubrrwbwuubbuuruubbruwrwwwrrbrwrwwbrbrubb
+wrgbbwbrrwwrrwggbbwrrurgurbgwgguggubwbbbruurwrwuggg
+wrggrugrrwwbgwwwwbugbbbbrwwgggrgggwbuguurgu
+wwugrwwbbggrgwurgrrbbuwgwgurrrbgruwrwugwrr
+bwrwubrgugguububbuggubbgggugrwuburuwrwrrrgbrwbrgr
+grgggugwbuburgbggguubwbrrgrguuwwbrgggwwwrgbgugw
+ubgbbugugbrugrwuguugwbggugbbwrgrbuurwbgrbrbgubbgwuwuwgbgw
+gurbubbwgwuwwgwbrbuwugguggbgrwgggrwuwwbgbgwbg
+rbuuugbburuuubgrubrbbrwgggwbbuugrugrrbbwggwr
+wrgrwrwbwggwrwuguwrurbugwbruwbggbggrrwurruwuuruwru
+uwguwwgbgggrubggwugwbwrbrbbwbgguuwrbgggwugrbwuwrwwgrur
+rgrwrgwuwbbbrgwrrwuubgrgbwwrrgburbgbbubbgubwrburbbwuuur
+wgruurgwubgubgbwbwbgggurbgbrggrbbgwgrrwggrwwgg
+wgwbwuwwwgwrbubwbuuuwwuuuuubuwbuurrgbgbubbbuuguburwbgru
+wrgbuurwbwbwguwrrugbrrwuuububbrgwbgugubbwgugrwgwwggwuwgrgrr
+guggbbgugbwgurrwbuwruggbbubbwguuuruuwwggwrbbgruburgrrbug
+wrgwuggurgbwgrgrggwwwgbbrwwgguwgguggbbgbbugwbrruwubrrrbrwuu
+bwgbuubgrwbugwbrwuugurwgbrggbgrwrggwbrgguwbr
+rbwwgrbgwwuwbrwgurbguwwgwrgwburwbbbwgrrgubugwurrggrwuww
+ggrwruugwguuwrbgbrgbrggrwugwggbrgwgurbwgbbrbgwubuggbbrgugw
+uuwwrwrrurgbrwrgbbuguruwwuwrwrugwrgrrbburgu
+grbbgurubwbwbgrwwgruurwbbuubrwwrrbwubwuwbbbrwu
+brrwwbbuwbwrbbgrbgbbuwwbbwrwwgubuwruwbgbwrwwwggug
+wrwbgbgggruurugwbrwwgbuguuwguurbgrgrguuwwwrgu
+wbwgbubrgbuwwwwbwbuuggugggggrwbwrwgrgguwrggrbwrgrburwbubb
+ubgwwrbbwbuwrguwrrwrrwggruwbgbrwuwbubububuggbggbrwbu
+urrbwuwwwrugbugwwgwbbubgrgbburuuwgbgguguugb
+uwbugbgubgrwgbruubbrrbrwgwuubuwbwbbuwrgbwugbr
+wrgwrrrbugbgwuwbwrubwgbbbuguwrrgrrwgbbgurwwbrbbggggrrbrruwu
+rwrrwbwwggubbguuubrwrurgrbwurguuuruuwgubwgbwbrbbgbgb
+grrbrgwrwbwbbgguwgguugrwurrbwwgwgbuubgrbuwbbbgbbbuw
+rgwubwwubrrgbrwwubuguugwbbwuwgbgubgruuruubgurrgwguuggwrw
+ruwuwuwbuwrgggwgrruguwwbrbuwwgugbuuwruwbwrbgwubwu
+ubgrgrguguwwbwrwwbgwurwurrrbggrrggubgrrbuuggbgg
+wrggwgrbugwwgruwwubrubgrgggwgubbbwwwwrwurubrwrggrwwbrgwgw
+gwbggrggwbgwgbrwwuuuwbbwrwgbguwruguuugwrbgrbbrrwrurrggbb
+brrbuwguwgrbbburrubrbwburbrwbgwbbwgrrgwugrg
+wgruguruwwgbrurbugrrrwrgwbrwuuruurrwrrgwuuwgwg
+buuwrbwbubggrwugwwbuwgubbbrbbgbubrrwrbbwwrrrrrwgugurrrbbb
+rbrrburuubrwurwgguggggubgbbruwwggburwwbwrb
+ubgruruwbrgbrbugrbburuwugrurugrwbwwguwuuwuwgubgbrgwrbbggbg
+gguuuwwrgggwgurrrubggubruubbugbbuuwgrruuwguguu
+uwbwggbrbrrbuggbwwwubwwuuggwrwwrurrwbgbwuwgw
+rwwwbuurburrrwubguwgrguguubrbgwbggbwurgwug
+gbgugwbuuwuwguwugwruwwbwurguubuurbbgggbgggrrwgwbgu
+gbrrbwwbuugurwbgrrwwwwgruurgbbgwwwgrguuuwgbgbgwwrbgwr
+gbwubwugbgwwugwgguruwubwggwuruwrbbwwbggggrgurwg
+wrgwbggbrgbuwrgrggwrwbbwwuwruuwuwrgrwwuwg
+wbrwgrgbrrrwuuuuuugwwrwbrbwbuubgggrrrbwuwruggwbwwubwbrgbwb
+uurbbgrrwrbwubwwwgbrrrrugbrbrbgbubrgrwbruuwggbbwbrg
+wrgbrrugrwrugbbrbwgrwbubruuguggwuwugrgbruurbbuubwbwur
+ggrwgwgwugbggwrbwbrwwrrrbgwrbwuwgwbuuurbwwuwbgubuurwb
+wrgrrbuwgurbgubwwwwguuwggwbrbwbwwwwuuwggb
+bbrurwwuwbgggrbgwrbrbgwurrrbbggrguwuwgggbbuuwggruwwgbw
+ugggggbwgrwubrrwurwgrwwurwrrgbrurbuguwbgwwrrbgwwwwrgwrrw
+rurbgbbwgrrgwuuwugwgbubwrwruugubgruwbwwrrg
+wrgrrwggbwruuugrwurbuwwgrgururgugwuwubbgbbgrwururwrgr
+wgrrbwrwrrbgwgwwrwubgrrurbgrwruguurrruwbwbrwugwr
+gbrwwbbbuwbwwuwubwggwrrbubuwrrwbrrrbuwbbbbugwbgu
+gurwruwurbgrurgbuwwgrrrwrbrrgwrbggwwrwruggurg
+bgururwbrguubbwbwbubbbrrbrbwrbgrubgwbruwbbwwruurruurrgurru
+bgugrwbbbgrbwuwrbubwbwubggwrwrwgrrbrubggwgwruwwuwwgrbwwb
+rbguwuwrrbwbbgrrururugbwwruwwrrwbugwguggubruuuuburrguugbu
+gurbggwbggwwurggbrgbgugrbgubrgrwrrgwguubwrurrrgrbwwbugwrw
+wrgbuwbugrgwrugguggbrrrgurruuuwgbguwgburb
+gurburbuuubuwrbwrubwuugwgwbuurrbwuurbrruuburwggw
+wgguwuuwguubuwrbwwwbbguwuugwrbubwugugrwwgwwwwggurwrbru
+wggbwgwwrggruuwbrubrrgbggrgwrwrgubbwuugwwuwrggrg
+bbwbgggubbwwuwrbggwbrgguugbuuwubguuwwrgbwuruwgruwr
+wuububrwurrgwubbgrbrrgubbbubgwbrbwrwrbwurwgg
+bgbbrbwwgubwbwbgggrwbrgbbuurgwbrrwgwgruwwrguuggubrbrurwr
+rbuuwrwbuubwrwrgrggurgwrurrgubbuwuugwbgwrrw
+wrggbwurgrrubgbgwrrgbruuuuwrruruubbbgrgubbggrwbbuugg
+buggwggrgbwbgwwbguwuwrbgwrbbwwrguwwuwggurbwgurbggubrrwgg
+guuggrbbuwbrwgrurrwwwuugwbwugbuwrbgrwguuwbgubgrbbg
+uuwwwbgugguuwuggrburwwubgurwwbuugrrwgugwuu
+buurwugwrrrgggubgwwwggwwgwugurbgrgwwuuubwuggurwrrbggbguwgr
+uuwwbgggubuubgurgwurbwguwrrwgwugubruuugwuguuuwwwgwgb
+rwbgrbwrwugbbwgwrwrgubbbbwwrrguwwubbugrbbwgbg
+ugrurggwgbgwgwrruugrwugwrgggbuurwbbubuugrbgbru
+uuugugurgbwwwwrbrgbrbggrbrurrgbbbrubburbbbbrrrbbbgww
+brbburruuwuwwbgwugrrrrggbwgrbrgwugrwbwggrr
+rbbbgburbwbwgbubbrugbgwgugwgrbubggwgwwuwbuurbuurgwrugrrg
+wuuuubrgwrwwwwugugrgwbrubbbbbgwbbgbubrrbbwgwwrgg
+ubrwubuurrrwugruubggwuwbbbuuwgbuubwrrrwbrwwwwbubwgwbrwwu
+brrurgrwwrruwrrubbwuwguuuggurbwgruuurbggggguwurrg
+uuggbrwgbugguwbgrrwgwwuuwuururwwbgbgrbgbuu
+grbbbrrgwrurugbwugbwgrgbgbgubugbrurruubgrugguubrwwugwuu
+ruwbwbugbbbgggbrugrgbbwbbgrguwrwuurrrbugbugbwwgbbugb
+ruwwrrwugwwbubggrubwbbgwrbgwggbwgguuubgbgubg
+uuwwugrbbwbbbbwwwwgrbbggurubwrrbbuuubrrggbgb
+wrgrgwuruwwugubrbrruggwrbbgrrubbggrbrwbruwubgbbrrwwgrgbgubgg
+urwuuwgugwwubuwrgwbwbgbbrwrwrrrrrbuburwbrurwuuruuugbrbb
+ggrurrwubwuwbugguuruuwggwwrgrgwwbbrwubgrbggbbur
+rwuggbgubrwuuwrwrbbbgbrgwwuwrbbuwrubguuugbbgwww
+wbrwgbrubgrrwbrwrwrwwrgrrbbrwggwbrguwwbrbbwggubbrruuwgrb
+bruwgrwrrgwrbugruuubwbruuurgbwgguwwruuurwbgr
+wubrurubrubrrwbuurgrgubgwbgrrurugguggbrguurbugr
+gbrggggugguugrrrwrgrrurggwwrgubuubwurugrbbrrrgg
+gwrbugwubbuuwrggubrrubbgggggbgbggwrbrgrwgwruwbwggubug
+gwrrgubggrurrgbbugruwgbwbrrbwuwuwbggwgrrrwgrggubbgurbg
+wrggwgwgwuwbrwwbwwgrurubugubgrgubuubbgwgbggwwwg
+wwrwbbrwwrwubwwwgbwrgguwuwrguwwggurgwgbburuuwwgwrggg
+wwrbwwbbgbgbuwbwuggrbrggurbugbrwuwugrrurwbruw
+wrbgrrggbwwgwwwgbwgbbrurwugwgugurguwbrgubr
+gwrbgbgugubgbgrugbrbgrgguwggwgubugwurwbwrgwbrugwwwb
+wbgugubwwwrurggwuwuwrrwwrwgbbbuwbbbrgrrgwurw
+uuuguubwbbwwgbbwwggguubgububgrguguubwwuugwwrwbr
+rwbgrwwgwrrruwugruuubbwrbrgubgrgwgbbbwwgburbubgrg
+wgbuugbgwbgwuwwgbwgwwguwrbuwurbuwrbwwrbbrwrrrubwrgbbug
+ubuwggbwubbgrwbbbwwrrbuwwuwwwwbbubbwrwbubwgrr
+uurwrurwrbbbgwrbggbwwruguwbwgwururgugrugruggggbgwwrrurggg
+wrggurbbwgrurggubgbggbrbgbgrwbgwrwbububgrwrwgrwwubuububu
+wrbwrgggggbuwubugurguuuugbwuwuuruburgwrwuwr
+bggbgwgrrrbwbwurgwwrggbwrwgbwuwwugwbwgbrrrbgrwwgwrwgbr
+ubuguruwbrrrgbwwgrgggrruwgggrgrbgrgwubggbrbuubw
+grurrbguuubuggbbguurbwwbrrurguwurubrbgwggrguwbrrgburruugb
+wrgbgrugrwwgwbgubbwbbrwubruggruuguuwubwgwurubggrbgwurrrrr
+wrgrwuguggwwurbwubgwrbrugbruruwuurgurbbgrgr
+wbbrguggbrbgwgwrugbuwrgbrgbuurrggggbrwgwwwuubbub
+grrgwbwwbruugggburwbwgrbrggwgwwwwuwwbrwrbwr
+guuwuuuwrgwwgbruugwwwrwuggrrgwbwwruuuuubububrwrbgurbw
+rrwrrurggwurggguurrrrurwugwwrruwrruubwrbbguubww
+grrwgrrrwbubggrrwbbgggbgwbbwubrbwwugugggwbg
+wrgrrggwurbwbrguwrurwbwrbrbrggggrguwbwgwgwrbggbgrbgrb
+bwrbwbwurbrugggwbgbrguwrugugrruubrggbwuurrubub
+wbgwwubuurwwubbwwgurgugbbbgrgwuwbbwrbgwbwguugurubr
+bbbbruwuwgwbuuugrrbgugrwgrrwwggugrggugbbgrrbw
+wrggrwwubwruwbugubgurrwrbrrwbgrgbgrruguuubgbbwuwbub
+wgurrgubgrgbgggurgubbugbbbruruggrbggrgrwwrw
+rurbwwuuugurguwgwguwurrruubuguwwrbbburrbrwwugrruuw
+wwubwbggrurbwubbrwbuuruwbgugbwgwgrugubbwbub
+ruwbrbuguwuuuwwbrbwguuwgrwuruugbrgbbwugubrrrgrgb
+rwrbrwrbwuwbuubrugwrubwbuuwbubrwbrgurgwgbgrurwrruuwu
+rugwbruruguuuwgrbwruggggwbgruwrwuggubgruurbubwug
+wgruguuruwbrrbwubuwgbrwugrgubgrwgggbwwuggbwbb
+gubuwrgurwrbrbrugrruuwgbbwubwwbgbgguwuuwwgrbrwuwr
+grrrgwguwrgbrbbwbbrwbgugwbrgggggbbrrurbbgbggwbuugwugb
+gbrbggrbgrrbbggggubbbwuugubgggbgbrurburugwwwurwwuuw
+wrgguubrrwbrrugwuuruurwbuuwgwbuugubgbrbbrrbgrbgwrrrwrgguww
+uwwburbrrururbrwgrwrgrbuwubgugwwwgwgwrrurggu
+rgubgrwgruwwwgrrruwrububgrrwuubbwrguuwwrrubururguwgbrg
+gguwbrrrrgwbbgrrbubugrgwwbbgwrgrguwuwwrwbwwgubbgubbuwuwgw
+rwgrwrbuwbwrrwrrbrrbbbuubgrgbrgugbuuuwbuuw
+rgguwggrbrurwrrgbruwbguwwwrubwurbrbrwwbwwggrrrwbwg
+rwruubwuwguwrurrubwuubbburwubbwwguguurggbbwuwb
+wgwubbbrrbgbwrgubrgguurrrbuurwubbbguubguuuurguwwr
+grwwbgggrbbrbwgrwbuuuruwwgbbuguurgburbrgugurwb
+rgugwuuubgubwwwwbbuurwwwburrrgurbwbgbuwwruuugu
+gurrwwgrgwrbrbbgurbwrrbubrbuwbuurrrguugggrrbwugbb
+wgwburbwwbubrgurgbbugwrbbrwggwgbwbrbgwburbbugbrrbggbwwwwg
+uwubgbbubwrbbbubgbbgwbuguububruubbbwuwrububbg
+ubgbbuwgwrbrggrbrwrgubbubrbbuurrgwbrggbuuwwwrgwubwrbbwb
+wgrbrwwwgrbgruwbbwgbggwuugggwggbrwrwbburgubgburrwrrwrwbw
+wrgrbgrbugubrwwwwuubbrbrbrwgwuwbbrgwrbwwrbwbrrubbrr
+wrgbburuubwbrrggwurbwwbrwuwwugrwrbwwbwgrwwwrbrurubrgrbw
+rwwbwgwbgggwuuwwbrwgwgrubwwwrrbgruubwrgguwrwr
+rurbrwwruuuuugwgbbwgwrgrbbwbrwwruuuwwgrbgwbbbuurururwww
+uwguwbuggubwuubururgbgurrbbugbwuwrgwwrbwwuuwruwuubgb
+rwubrrrubgwubbgbubrrrrwbbbgbgrbbbuuwrwuggwgugr
+buwrgbggrburwwrrwrrgbrwbwurwgwubgwbwgrrgwbwrrbrbrgrbgububb
+wuuurwgbuwwwwuwbbugbrwurrgguwbbbbuuggwbrrwbgrbrgwrgrubug
+bbuwbrubrwbgurwbwbguugwwgwrwbgbwruurwuwbuuruuggr
+rbbrwwbbwuuwwuuurburrrgwgrwbbrrbuggwrwrgruugbu
+gbrgubuurgbgguwwwwubbgrbwrrurburugbwgbubbwruuuuruuwbbgwguw
+wurwggrggwwrwugbwgrwuuwrugbuuggbgrwrgwggrgugrgrwrrwbb
+rgwrwuwuwrgubuwbgurwrgurwuuuwgwwrgwgrgruwuwwggwurwrbbuw
+wrwwrgwbwgbugggrguuurwwuwrbrwrrruwwbrrrgrruubg
+wbwrrruuurgrrrwrbuwbggbguwugrbwbggbuburgruwgbbruubrwbrgrur
+uuubuguurruuwwurbuwbgwrrrbrbwrwbuwubugrrruwuggrrwb
+rrbggbubgrruubbgubuwubbgwuubgbrruwuugggbrbuubgugg
+buwugbwbbrugbwbgwurguwbwwbbgbbbuguwgrwburrgggbgbguruww
+wrgbgwurgrbrggrburguuubugbwgugrwbwwwwbbuubw
+gwruuubuubbbwurbgurrrbwwbburguugbwbrrgbubrwwrrwwgbbgbu
+wgubuugggrugrwrrggugguwgbwwwruuuwwurwbwgwbbwgr
+buwwwgrruuuwrwgggbbggbguuwwugwwguuuuuruubrruubbuwubggbgwrg
+gwrgbgubrwuruwuruguubbuwrbggwwrguugrrgwwbbwgwrbbwbgguuw
+wrgrbwuburwgwggggrrbrgrbbguuwuwbgrbwbubbbbb
+wuuurbguuwrurgggrwbgwrbgggrgrggrwuwguwrrugugrugwbuwbrug
+ugbubbugwbwgugbwuurwbuugbgwbgwgbrurgruuruubgugbwugwubu
+rgguwubwruubugbrrguruugrrwbrgggurrgbugwbrggu
+ggwrgrrrrwrggbbwwuwgbrrrugrrubwwwrgrruugurwgrbgwbg
+gugwrgwbugugrruubbbgugrwuurbruubwrrbbuuubbb
+gbuuggruguburwbrrbrggrguwguubugbwggbgwuwrwgrgub
+urbwrguguuwrugrbwgrrgbwrwrwwuuwgbgwbururggwurgrw
+wuwurrubrwubugbgwgwwuguugbgbuwrwbuwrgbggrurgruwuwuuu
+grrugwbrrbbwbrgguuwbubbgrugrwbwrurwggbwwwr
+rwbggurbrwubrbgwuwruwbrgwwgrubuuuurbbggbwrrrwur
+wwbugrgrgruwrgbugrwrgwgrbruuuuubbubrwbwrgrb
+wbbbrgwwrrrwwbrrwwwuwugwbrwgrbwuwuggbuwruuugubgbg
+wrgbuggbbrbrubgubbbuwrubbuwwgbggbbwgrwrruwgguwguwruubw
+guggwbwbgrrubbrwrrwgugguuuwrgbwgbbguwbbubw

y2024/resources/20_input.txt

@@ -0,0 +1,141 @@
+#############################################################################################################################################
+#...###.....#...#...#...#...#...#...###...#.....#.........#...#.......#...#.....#...#.........###...#.....#.............#...#...#.......#...#
+#.#.###.###.#.#.#.#.#.#.#.#.#.#.#.#.###.#.#.###.#.#######.#.#.#.#####.#.#.#.###.#.#.#.#######.###.#.#.###.#.###########.#.#.#.#.#.#####.#.#.#
+#.#.#...#...#.#...#...#...#...#...#...#.#...#...#.#.......#.#.#.#.....#.#.#...#...#.#.#.......#...#...#...#.#.....#.....#.#.#.#.#.#.....#.#.#
+#.#.#.###.###.#######################.#.#####.###.#.#######.#.#.#.#####.#.###.#####.#.#.#######.#######.###.#.###.#.#####.#.#.#.#.#.#####.#.#
+#.#.#...#.###.....#.............#...#.#.#...#.#...#.#...###.#...#.......#.#...#...#.#.#.###.....#.....#.....#.###...#.....#.#.#...#.......#.#
+#.#.###.#.#######.#.###########.#.#.#.#.#.#.#.#.###.#.#.###.#############.#.###.#.#.#.#.###.#####.###.#######.#######.#####.#.#############.#
+#.#.....#.#...#...#...#.....###...#.#.#.#.#...#...#...#...#.#...#.........#.....#.#...#...#.......#...#...#...#...###.....#.#.#.............#
+#.#######.#.#.#.#####.#.###.#######.#.#.#.#######.#######.#.#.#.#.###############.#######.#########.###.#.#.###.#.#######.#.#.#.#############
+#.......#.#.#.#.......#...#...#.....#.#.#.#...###.#.......#...#.#.#.......#...#...#.......#.....###.#...#...###.#...#.....#...#...#.........#
+#######.#.#.#.###########.###.#.#####.#.#.#.#.###.#.###########.#.#.#####.#.#.#.###.#######.###.###.#.#########.###.#.###########.#.#######.#
+#...#...#.#.#.#...###...#...#.#.....#.#.#...#.#...#.#...###.....#...#.....#.#.#.#...###...#...#.#...#.#...#...#...#...#...........#.#.......#
+#.#.#.###.#.#.#.#.###.#.###.#.#####.#.#.#####.#.###.#.#.###.#########.#####.#.#.#.#####.#.###.#.#.###.#.#.#.#.###.#####.###########.#.#######
+#.#.#...#.#.#.#.#...#.#...#.#.#...#.#.#.#.....#.#...#.#...#.....#.....###...#...#.#...#.#.#...#.#...#.#.#...#...#...#...#...#.....#.#.......#
+#.#.###.#.#.#.#.###.#.###.#.#.#.#.#.#.#.#.#####.#.###.###.#####.#.#######.#######.#.#.#.#.#.###.###.#.#.#######.###.#.###.#.#.###.#.#######.#
+#.#.....#.#.#.#.#...#...#...#...#...#...#.......#.....#...#...#.#.......#.....#...#.#.#.#.#...#.###.#.#.....#...#...#.....#...#...#.#.......#
+#.#######.#.#.#.#.#####.###############################.###.#.#.#######.#####.#.###.#.#.#.###.#.###.#.#####.#.###.#############.###.#.#######
+#.......#...#.#.#...###...#...#.....#...#.............#.#...#.#.#.......#.....#.....#.#.#.#...#...#.#.###...#.###.#.............#...#.......#
+#######.#####.#.###.#####.#.#.#.###.#.#.#.###########.#.#.###.#.#.#######.###########.#.#.#.#####.#.#.###.###.###.#.#############.#########.#
+#.....#.....#.#.#...#...#...#.#.#...#.#.#.#.....#...#...#...#...#.....#...#...........#.#.#.....#...#.#...#...#...#.......###...#.#.........#
+#.###.#####.#.#.#.###.#.#####.#.#.###.#.#.#.###.#.#.#######.#########.#.###.###########.#.#####.#####.#.###.###.#########.###.#.#.#.#########
+#...#.......#...#...#.#.#...#...#.....#.#.#.#...#.#...###...#.........#...#...#.....#...#.#.....#...#.#...#.#...#...#.....#...#.#.#.#.......#
+###.###############.#.#.#.#.###########.#.#.#.###.###.###.###.###########.###.#.###.#.###.#.#####.#.#.###.#.#.###.#.#.#####.###.#.#.#.#####.#
+###.#.....#.......#...#.#.#.....#.......#...#.....#...#...#...#.....#...#.#...#...#.#.#...#...#...#...#...#...#...#.#...###...#...#...#...#.#
+###.#.###.#.#####.#####.#.#####.#.#################.###.###.###.###.#.#.#.#.#####.#.#.#.#####.#.#######.#######.###.###.#####.#########.#.#.#
+#...#.###...###...#...#...#.....#.........#...#.....###...#...#.#...#.#.#.#.###...#.#.#...#...#.#...###.....#...###...#...###.#.....#...#.#.#
+#.###.#########.###.#.#####.#############.#.#.#.#########.###.#.#.###.#.#.#.###.###.#.###.#.###.#.#.#######.#.#######.###.###.#.###.#.###.#.#
+#...#.#...#.....#...#.....#.#...###.......#.#...###...#...#...#.#.#...#.#.#...#...#.#.#...#.#...#.#...#...#.#.....###...#.....#...#...###...#
+###.#.#.#.#.#####.#######.#.#.#.###.#######.#######.#.#.###.###.#.#.###.#.###.###.#.#.#.###.#.###.###.#.#.#.#####.#####.#########.###########
+###...#.#.#...#...#.......#...#...#.......#...#...#.#...#...###.#.#...#.#...#.#...#.#.#...#.#.###.#...#.#.#.#.....#...#.#...#...#...#...#...#
+#######.#.###.#.###.#############.#######.###.#.#.#.#####.#####.#.###.#.###.#.#.###.#.###.#.#.###.#.###.#.#.#.#####.#.#.#.#.#.#.###.#.#.#.#.#
+#.......#.....#...#.........#...#.#...#...#...#.#.#.....#.#...#.#.#...#.#...#.#.#...#.#...#.#...#.#...#.#.#.#.....#.#.#...#...#.....#.#...#.#
+#.###############.#########.#.#.#.#.#.#.###.###.#.#####.#.#.#.#.#.#.###.#.###.#.#.###.#.###.###.#.###.#.#.#.#####.#.#.###############.#####.#
+#.......#...#.....#...#...#...#.#...#.#.#...###.#.#...#.#.#.#.#.#.#...#.#.#...#.#.###.#.###.#...#...#.#.#...#...#...#...###...#...#...#...#.#
+#######.#.#.#.#####.#.#.#.#####.#####.#.#.#####.#.#.#.#.#.#.#.#.#.###.#.#.#.###.#.###.#.###.#.#####.#.#.#####.#.#######.###.#.#.#.#.###.#.#.#
+#...###...#...#.....#...#.....#.....#...#.#...#.#.#.#...#...#.#.#...#.#.#.#.#...#...#.#...#.#...#...#.#.#.....#.........#...#...#...#...#...#
+#.#.###########.#############.#####.#####.#.#.#.#.#.#########.#.###.#.#.#.#.#.#####.#.###.#.###.#.###.#.#.###############.###########.#######
+#.#.#...###...#.............#.#...#.....#...#.#.#.#...#.......#...#...#.#.#.#.#.....#...#.#.#...#...#.#.#.............###.#.......#...#...###
+#.#.#.#.###.#.#############.#.#.#.#####.#####.#.#.###.#.#########.#####.#.#.#.#.#######.#.#.#.#####.#.#.#############.###.#.#####.#.###.#.###
+#.#...#.....#.#...#...#.....#...#.......#.....#.#.#...#.....#...#...#...#.#.#.#.#...#...#...#.#...#.#.#.#.......#...#.....#.....#.#.....#...#
+#.###########.#.#.#.#.#.#################.#####.#.#.#######.#.#.###.#.###.#.#.#.#.#.#.#######.#.#.#.#.#.#.#####.#.#.###########.#.#########.#
+#.#.....#...#...#...#...#...#...#...#...#.....#.#.#.......#...#.#...#...#.#...#...#.#.....#...#.#...#...#.....#...#...#...#.....#...........#
+#.#.###.#.#.#############.#.#.#.#.#.#.#.#####.#.#.#######.#####.#.#####.#.#########.#####.#.###.#############.#######.#.#.#.#################
+#.#.#...#.#.........#...#.#.#.#.#.#...#.....#...#.#.....#.#.....#...###.#.#.........#...#.#.....#...........#.......#.#.#.#...#...#...#...###
+#.#.#.###.#########.#.#.#.#.#.#.#.#########.#####.#.###.#.#.#######.###.#.#.#########.#.#.#######.#########.#######.#.#.#.###.#.#.#.#.#.#.###
+#.#.#.....#.......#.#.#...#.#.#.#.#.......#.#.....#.###.#.#...#...#...#...#.....#...#.#...###...#.........#.#...#...#...#...#...#...#.#.#...#
+#.#.#######.#####.#.#.#####.#.#.#.#.#####.#.#.#####.###.#.###.#.#.###.#########.#.#.#.#######.#.#########.#.#.#.#.#########.#########.#.###.#
+#...###...#.....#.#...#.....#.#...#.....#.#.#.....#...#.#...#...#...#...#.......#.#.#...###...#...........#...#...#...#####...........#...#.#
+#######.#.#####.#.#####.#####.#########.#.#.#####.###.#.###.#######.###.#.#######.#.###.###.#######################.#.###################.#.#
+#...#...#.#.....#.#...#.......#.........#...###...#...#.#...#.......#...#.#.....#.#...#...#.#...#...#.....#...#...#.#...###...#...#...#...#.#
+#.#.#.###.#.#####.#.#.#########.###############.###.###.#.###.#######.###.#.###.#.###.###.#.#.#.#.#.#.###.#.#.#.#.#.###.###.#.#.#.#.#.#.###.#
+#.#.#...#.#.....#.#.#.#...###...#.............#.#...###.#.#...#...#...###.#.#...#...#.#...#...#...#.#.#...#.#.#.#...#...#...#...#...#...#...#
+#.#.###.#.#####.#.#.#.#.#.###.###.###########.#.#.#####.#.#.###.#.#.#####.#.#.#####.#.#.###########.#.#.###.#.#.#####.###.###############.###
+#.#.....#.......#...#...#...#...#.#...#.......#...#...#...#...#.#.#.....#...#.#...#.#.#.#...........#.#.....#...#.....#...#...#.....#...#...#
+#.#########################.###.#.#.#.#.###########.#.#######.#.#.#####.#####.#.#.#.#.#.#.###########.###########.#####.###.#.#.###.#.#.###.#
+#.....#...#.............#...###...#.#...#...#####...#.......#...#.#.....###...#.#.#.#...#...........#.###.....#...###...#...#...###...#.....#
+#####.#.#.#.###########.#.#########.#####.#.#####.#########.#####.#.#######.###.#.#.###############.#.###.###.#.#####.###.###################
+#...#...#.#.#...........#...#.......#...#.#...#...#.........###...#.......#...#.#.#.#.............#.#.#...#...#.......#...#...#...#.........#
+#.#.#####.#.#.#############.#.#######.#.#.###.#.###.###########.#########.###.#.#.#.#.###########.#.#.#.###.###########.###.#.#.#.#.#######.#
+#.#.....#...#.............#.#...#.....#...#...#...#.#...###...#...#.......###.#.#...#...........#.#...#...#...........#...#.#.#.#.#.....#...#
+#.#####.#################.#.###.#.#########.#####.#.#.#.###.#.###.#.#########.#.###############.#.#######.###########.###.#.#.#.#.#####.#.###
+#.#...#...###...#.........#...#...#...#...#.......#...#.#...#...#.#.....#.....#.....#.....#.....#.#...###...........#.....#.#...#.###...#...#
+#.#.#.###.###.#.#.###########.#####.#.#.#.#############.#.#####.#.#####.#.#########.#.###.#.#####.#.#.#############.#######.#####.###.#####.#
+#.#.#...#.....#...#.....#...#...#...#...#.#...#...#...#...#...#.#.#.....#.......#...#...#.#.....#.#.#...............#.......#.....#...#.....#
+#.#.###.###########.###.#.#.###.#.#######.#.#.#.#.#.#.#####.#.#.#.#.###########.#.#####.#.#####.#.#.#################.#######.#####.###.#####
+#.#.###.....#...#...###...#...#.#...#...#...#...#...#.#.....#.#.#.#.....#.......#.#.....#.#.....#...#...............#...#.....#...#...#.#...#
+#.#.#######.#.#.#.###########.#.###.#.#.#############.#.#####.#.#.#####.#.#######.#.#####.#.#########.#############.###.#.#####.#.###.#.#.#.#
+#.#.#.......#.#.#.#.......###.#.###...#.#...#.......#.#.....#...#.#...#.#...#...#.#.....#.#...........#.........#...###.#.......#.....#...#.#
+#.#.#.#######.#.#.#.#####.###.#.#######.#.#.#.#####.#.#####.#####.#.#.#.###.#.#.#.#####.#.#############.#######.#.#####.###################.#
+#...#.#...#...#...#.....#.....#.......#...#...#...#.#...#...#.....#.#.#.###.#.#...#.....#.....#.......#.......#.#.#.....#.........#...#...#.#
+#####.#.#.#.###########.#############.#########.#.#.###.#.###.#####.#.#.###.#.#####.#########.#.#####.#######.#.#.#.#####.#######.#.#.#.#.#.#
+#...#...#...#.......###...#.........#.#.....#...#...#...#...#.......#.#.#...#...###...#.....#...#...#.........#...#.#.....#.....#.#.#.#.#...#
+#.#.#########.#####.#####.#.#######.#.#.###.#.#######.#####.#########.#.#.#####.#####.#.###.#####.#.###############.#.#####.###.#.#.#.#.#####
+#.#...........#...#.......#...#.....#...###.#.....###.......#...#.....#.#...#...#.....#.###.......#.......#...#...#.#.......#...#...#...#...#
+#.#############.#.###########.#.###########.#####.###########.#.#.#####.###.#.###.#####.#################.#.#.#.#.#.#########.###########.#.#
+#.#.............#.........#...#...........#.#...#.............#.#.#.....###.#...#.#.....#...........#...#...#.#.#.#.#.....#...#...........#.#
+#.#.#####################.#.#############.#.#.#.###############.#.#.#######.###.#.#.#####.#########.#.#.#####.#.#.#.#.###.#.###.###########.#
+#...#...#.................#.###...#...#...#...#.#.......#.......#...#.......#...#...#.....#.......#...#.......#.#...#...#...###.#.......#...#
+#####.#.#.#################.###.#.#.#.#.#######.#.#####.#.###########.#######.#######.#####.#####.#############.#######.#######.#.#####.#.###
+#.....#...#...#.....#.....#.#...#...#...#...###.#.....#.#.....###...#.........#.......#...#.#...#.....#...#.....#.....#.........#.....#...###
+#.#########.#.#.###.#.###.#.#.###########.#.###.#####.#.#####.###.#.###########.#######.#.#.#.#.#####.#.#.#.#####.###.###############.#######
+#.#.....#...#...###...###...#.............#...#...#...#.......#...#...#...#...#.........#...#.#.#...#...#...#.....###.#.......#.......#...###
+#.#.###.#.###################################.###.#.###########.#####.#.#.#.#.###############.#.#.#.#########.#######.#.#####.#.#######.#.###
+#...###...#.......###...#...#.........#.......###...###...###...#.....#.#.#.#.#############...#...#.#...#...#.......#.#.....#...#.......#...#
+###########.#####.###.#.#.#.#.#######.#.###############.#.###.###.#####.#.#.#.#############.#######.#.#.#.#.#######.#.#####.#####.#########.#
+#...........#...#.#...#...#...#.....#.#...#...#...#...#.#.#...#...#...#.#.#.#S#############.......#...#...#...#...#.#.#...#...###.#.........#
+#.###########.#.#.#.###########.###.#.###.#.#.#.#.#.#.#.#.#.###.###.#.#.#.#.#####################.###########.#.#.#.#.#.#.###.###.#.#########
+#.....#.......#.#...#...#.......#...#.#...#.#.#.#...#.#.#.#...#.#...#.#.#.#.........#########...#.#.........#...#...#...#...#.....#.........#
+#####.#.#######.#####.#.#.#######.###.#.###.#.#.#####.#.#.###.#.#.###.#.#.#########.#########.#.#.#.#######.###############.###############.#
+#.....#.#.......#.....#...#...###...#...###.#.#.....#...#...#.#.#.#...#.#.#...#...#.#########.#...#.#.......#.............#...#.............#
+#.#####.#.#######.#########.#.#####.#######.#.#####.#######.#.#.#.#.###.#.#.#.#.#.#.#########.#####.#.#######.###########.###.#.#############
+#.#...#.#.........#.........#.......#.......#.....#...#.....#.#...#.....#.#.#.#.#.#.#########.....#.#.....#...#.......#...###.#.........#...#
+#.#.#.#.###########.#################.###########.###.#.#####.###########.#.#.#.#.#.#############.#.#####.#.###.#####.#.#####.#########.#.#.#
+#...#...#...........#...#...#.........#...........###.#.....#.........#...#.#.#.#...#############...#...#...#...#...#.#.#...#.#...#.....#.#.#
+#########.###########.#.#.#.#.#########.#############.#####.#########.#.###.#.#.#####################.#.#####.###.#.#.#.#.#.#.#.#.#.#####.#.#
+#.......#...#...#.....#...#.#.#.......#...........#...#.....#...#...#.#.#...#.#.....#####......E#.....#.......###.#.#...#.#.#.#.#.#.......#.#
+#.#####.###.#.#.#.#########.#.#.#####.###########.#.###.#####.#.#.#.#.#.#.###.#####.#####.#######.###############.#.#####.#.#.#.#.#########.#
+#.....#.###...#...#...###...#.#.#...#...#...#...#.#...#.#...#.#...#...#.#...#.#...#.#.....#.....#.................#.....#.#.#.#.#.#.....#...#
+#####.#.###########.#.###.###.#.#.#.###.#.#.#.#.#.###.#.#.#.#.#########.###.#.#.#.#.#.#####.###.#######################.#.#.#.#.#.#.###.#.###
+###...#...#.........#.....#...#...#...#...#...#...#...#...#.#.....#.....#...#.#.#...#.......#...#...#...#...#.....#.....#.#.#...#.#.#...#.###
+###.#####.#.###############.#########.#############.#######.#####.#.#####.###.#.#############.###.#.#.#.#.#.#.###.#.#####.#.#####.#.#.###.###
+#...#.....#.......#.........#.........#.....#.....#.....#...###...#.#...#...#.#.#.............#...#.#.#.#.#...###...#.....#.#...#...#...#...#
+#.###.###########.#.#########.#########.###.#.###.#####.#.#####.###.#.#.###.#.#.#.#############.###.#.#.#.###########.#####.#.#.#######.###.#
+#...#...#.........#.###...###.......###.#...#.#...#...#.#.#...#.#...#.#.###.#.#.#.###...###...#.#...#.#.#...#...#...#.#.....#.#.#.....#.#...#
+###.###.#.#########.###.#.#########.###.#.###.#.###.#.#.#.#.#.#.#.###.#.###.#.#.#.###.#.###.#.#.#.###.#.###.#.#.#.#.#.#.#####.#.#.###.#.#.###
+###...#.#.........#.#...#...#.......#...#.#...#.#...#...#.#.#.#.#...#.#.....#.#.#.....#.#...#.#.#.#...#...#...#...#...#.......#...#...#.#...#
+#####.#.#########.#.#.#####.#.#######.###.#.###.#.#######.#.#.#.###.#.#######.#.#######.#.###.#.#.#.#####.#########################.###.###.#
+#.....#.........#...#.....#...#...#...#...#.#...#...#.....#.#.#...#...###.....#.....#...#.###...#.#.###...#...#...#...#.............###...#.#
+#.#############.#########.#####.#.#.###.###.#.#####.#.#####.#.###.#######.#########.#.###.#######.#.###.###.#.#.#.#.#.#.#################.#.#
+#.....#...#...#.......###.#.....#.#.###...#.#...#...#.....#.#.#...#.......#...#...#.#...#.....###.#.#...#...#...#.#.#.#.............#.....#.#
+#####.#.#.#.#.#######.###.#.#####.#.#####.#.###.#.#######.#.#.#.###.#######.#.#.#.#.###.#####.###.#.#.###.#######.#.#.#############.#.#####.#
+#.....#.#...#.......#.....#.#.....#...###...#...#.......#...#.#.###.#.....#.#.#.#.#.#...#...#...#...#...#.###...#.#.#.#...#...#.....#.#...#.#
+#.#####.###########.#######.#.#######.#######.#########.#####.#.###.#.###.#.#.#.#.#.#.###.#.###.#######.#.###.#.#.#.#.#.#.#.#.#.#####.#.#.#.#
+#.....#.#...........#...#...#.....#...#.......#...#.....#.....#...#...#...#.#.#.#.#.#.#...#.#...#.......#.....#.#...#...#...#.#.....#...#.#.#
+#####.#.#.###########.#.#.#######.#.###.#######.#.#.#####.#######.#####.###.#.#.#.#.#.#.###.#.###.#############.#############.#####.#####.#.#
+#.....#.#...........#.#.#...###...#...#...#...#.#.#.....#...#...#.###...#...#.#.#.#.#.#.#...#.#...#.....#.....#.............#.#...#.....#.#.#
+#.#####.###########.#.#.###.###.#####.###.#.#.#.#.#####.###.#.#.#.###.###.###.#.#.#.#.#.#.###.#.###.###.#.###.#############.#.#.#.#####.#.#.#
+#...#...#...........#.#...#.#...#...#...#...#...#.#.....###.#.#.#.#...#...###.#.#...#...#...#.#.#...###.#...#.#...#.....#...#...#.......#...#
+###.#.###.###########.###.#.#.###.#.###.#########.#.#######.#.#.#.#.###.#####.#.###########.#.#.#.#####.###.#.#.#.#.###.#.###################
+###.#...#...........#.#...#.#...#.#...#.#.........#.###.....#.#.#.#...#.....#.#...#.......#.#.#.#...#...#...#.#.#.#...#.#...###.............#
+###.###.###########.#.#.###.###.#.###.#.#.#########.###.#####.#.#.###.#####.#.###.#.#####.#.#.#.###.#.###.###.#.#.###.#.###.###.###########.#
+#...#...###.........#.#.....#...#...#...#.........#...#.#.....#.#.###...#...#.....#.....#...#.#.#...#...#...#.#.#.#...#...#.....#...#...#...#
+#.###.#####.#########.#######.#####.#############.###.#.#.#####.#.#####.#.#############.#####.#.#.#####.###.#.#.#.#.#####.#######.#.#.#.#.###
+#.....#.....#.....#...#.......#.....#...#.........#...#.#...###.#.#.....#.#...###.......#...#.#.#.#.....#...#...#.#.....#.#.......#.#.#.#...#
+#######.#####.###.#.###.#######.#####.#.#.#########.###.###.###.#.#.#####.#.#.###.#######.#.#.#.#.#.#####.#######.#####.#.#.#######.#.#.###.#
+#.......#...#.#...#.###...#...#.....#.#.#.......#...###...#.#...#.#.....#...#...#...#...#.#.#.#.#.#.....#.....#...#.....#.#.......#...#...#.#
+#.#######.#.#.#.###.#####.#.#.#####.#.#.#######.#.#######.#.#.###.#####.#######.###.#.#.#.#.#.#.#.#####.#####.#.###.#####.#######.#######.#.#
+#...#...#.#.#.#...#...#...#.#.....#...#.#.......#.....#...#.#.#...#.....#.......###.#.#.#.#...#.#.#...#.#.....#...#.....#...#.....#.....#.#.#
+###.#.#.#.#.#.###.###.#.###.#####.#####.#.###########.#.###.#.#.###.#####.#########.#.#.#.#####.#.#.#.#.#.#######.#####.###.#.#####.###.#.#.#
+#...#.#.#.#.#.#...#...#.....#.....#.....#.#.....#.....#.#...#.#...#.#...#.......#...#.#.#.....#.#.#.#...#...#...#.#.....#...#.......#...#...#
+#.###.#.#.#.#.#.###.#########.#####.#####.#.###.#.#####.#.###.###.#.#.#.#######.#.###.#.#####.#.#.#.#######.#.#.#.#.#####.###########.#######
+#...#.#.#.#.#.#...#.#.......#.....#.....#.#.#...#.....#.#.###...#.#.#.#.#.....#.#.#...#...#...#.#.#...#.....#.#...#.....#.#...#.......#...###
+###.#.#.#.#.#.###.#.#.#####.#####.#####.#.#.#.#######.#.#.#####.#.#.#.#.#.###.#.#.#.#####.#.###.#.###.#.#####.#########.#.#.#.#.#######.#.###
+#...#.#.#.#.#.#...#.#.#...#.......#...#.#.#.#...#...#.#.#.#...#...#...#.#.###.#.#.#.....#.#.#...#...#.#.....#.#...#...#.#.#.#.#...#.....#...#
+#.###.#.#.#.#.#.###.#.#.#.#########.#.#.#.#.###.#.#.#.#.#.#.#.#########.#.###.#.#.#####.#.#.#.#####.#.#####.#.#.#.#.#.#.#.#.#.###.#.#######.#
+#.#...#...#.#.#.#...#...#...#...#...#.#.#.#...#.#.#.#.#.#...#...#.......#...#.#.#...#...#.#.#.#.....#.#.....#.#.#...#.#.#.#.#...#...#...#...#
+#.#.#######.#.#.#.#########.#.#.#.###.#.#.###.#.#.#.#.#.#######.#.#########.#.#.###.#.###.#.#.#.#####.#.#####.#.#####.#.#.#.###.#####.#.#.###
+#.#...#.....#.#.#.#.........#.#.#...#.#.#.#...#.#.#.#.#.#...#...#...#...#...#.#.#...#.#...#.#.#.#.....#.....#.#.....#.#.#.#...#...#...#.#...#
+#.###.#.#####.#.#.#.#########.#.###.#.#.#.#.###.#.#.#.#.#.#.#.#####.#.#.#.###.#.#.###.#.###.#.#.#.#########.#.#####.#.#.#.###.###.#.###.###.#
+#.....#.......#...#...........#.....#...#...###...#...#...#...#####...#...###...#.....#.....#...#...........#.......#...#.....###...###.....#
+#############################################################################################################################################

y2024/resources/21_input.txt

@@ -0,0 +1,5 @@
+340A
+149A
+582A
+780A
+463A

y2024/src/bin/d18.rs

@@ -0,0 +1,27 @@
+use std::{fs, time::Instant};
+
+use utils::time::get_elapsed_string;
+use y2024::days::d18;
+
+fn main() {
+    let now = Instant::now();
+    println!("Part 1:");
+    part1();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+    let now = Instant::now();
+    println!("Part 2:");
+    part2();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+}
+
+fn part1() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/18_input.txt")).unwrap();
+    println!("{}", d18::process_part1(&content));
+}
+
+fn part2() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/18_input.txt")).unwrap();
+    println!("{}", d18::process_part2(&content));
+}

y2024/src/bin/d19.rs

@@ -0,0 +1,27 @@
+use std::{fs, time::Instant};
+
+use utils::time::get_elapsed_string;
+use y2024::days::d19;
+
+fn main() {
+    let now = Instant::now();
+    println!("Part 1:");
+    part1();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+    let now = Instant::now();
+    println!("Part 2:");
+    part2();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+}
+
+fn part1() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/19_input.txt")).unwrap();
+    println!("{}", d19::process_part1(&content));
+}
+
+fn part2() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/19_input.txt")).unwrap();
+    println!("{}", d19::process_part2(&content));
+}

y2024/src/bin/d20.rs

@@ -0,0 +1,27 @@
+use std::{fs, time::Instant};
+
+use utils::time::get_elapsed_string;
+use y2024::days::d20;
+
+fn main() {
+    let now = Instant::now();
+    println!("Part 1:");
+    part1();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+    let now = Instant::now();
+    println!("Part 2:");
+    part2();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+}
+
+fn part1() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/20_input.txt")).unwrap();
+    println!("{}", d20::process_part1(&content));
+}
+
+fn part2() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/20_input.txt")).unwrap();
+    println!("{}", d20::process_part2(&content));
+}

y2024/src/bin/d21.rs

@@ -0,0 +1,27 @@
+use std::{fs, time::Instant};
+
+use utils::time::get_elapsed_string;
+use y2024::days::d21;
+
+fn main() {
+    let now = Instant::now();
+    println!("Part 1:");
+    part1();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+    let now = Instant::now();
+    println!("Part 2:");
+    part2();
+    println!("Ran in {}", get_elapsed_string(now.elapsed()));
+}
+
+fn part1() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/21_input.txt")).unwrap();
+    println!("{}", d21::process_part1(&content));
+}
+
+fn part2() {
+    let root = env!("CARGO_MANIFEST_DIR");
+    let content = fs::read_to_string(format!("{root}/resources/21_input.txt")).unwrap();
+    println!("{}", d21::process_part2(&content));
+}

y2024/src/days/d17.rs

@@ -2,7 +2,7 @@ use std::{collections::HashMap, error::Error};
 
 use itertools::Itertools;
 
-pub fn process_part1(input: &str) -> (String, HashMap<&str, u32>) {
+pub fn process_part1(input: &str) -> (String, HashMap<&str, u64>) {
     let (registers, program) = input.split_once("\n\n").unwrap();
     let mut registers = parse_registers(registers);
     let (_, instructions) = program.split_once(": ").unwrap();
@@ -19,7 +19,7 @@ pub fn process_part1(input: &str) -> (String, HashMap<&str, u32>) {
         .collect_vec()
         .concat();
 
-    let mut instruction_pointer: u32 = 0;
+    let mut instruction_pointer: u64 = 0;
 
     while let Some((opcode, operand)) = instructions.get(instruction_pointer as usize) {
         let opcode = OpCodes::try_from(*opcode).unwrap();
@@ -37,7 +37,7 @@ pub fn process_part1(input: &str) -> (String, HashMap<&str, u32>) {
     (out.into_iter().join(","), registers)
 }
 
-pub fn process_part2(input: &str) -> u32 {
+pub fn process_part2(input: &str) -> u64 {
     let (registers, program) = input.split_once("\n\n").unwrap();
     let mut registers = parse_registers(registers);
     let (_, instructions) = program.split_once(": ").unwrap();
@@ -56,30 +56,35 @@ pub fn process_part2(input: &str) -> u32 {
         .iter()
         .map(|(opcode, operand)| {
             [
-                opcode.parse::<u32>().unwrap(),
+                opcode.parse::<u64>().unwrap(),
-                operand.parse::<u32>().unwrap(),
+                operand.parse::<u64>().unwrap(),
             ]
         })
         .collect_vec()
         .concat();
     let mut a = 0;
-    loop {
+    for idx in 1..=orig.len() {
-        registers.insert("A", a);
+        let target = orig[orig.len() - idx..].to_vec();
-        let out = exec_program(instructions.clone(), &mut registers);
-        if out == orig {
-            println!("{orig:?}");
-            println!("{out:?}");
-            break;
-        }
-        a += 1;
-    }
 
+        let mut new_a = a << 3;
+        loop {
+            registers.insert("A", new_a);
+            let out = exec_program(instructions.clone(), &mut registers);
+            //println!("target {target:?}");
+            //println!("output {out:?}");
+            if out == target {
+                a = new_a;
+                break;
+            }
+            new_a += 1;
+        }
+    }
     a
 }
 
-fn exec_program(instructions: Vec<(&str, &str)>, registers: &mut HashMap<&str, u32>) -> Vec<u32> {
+fn exec_program(instructions: Vec<(&str, &str)>, registers: &mut HashMap<&str, u64>) -> Vec<u64> {
     let mut out = Vec::new();
-    let mut instruction_pointer: u32 = 0;
+    let mut instruction_pointer: u64 = 0;
 
     while let Some((opcode, operand)) = instructions.get(instruction_pointer as usize) {
         let opcode = OpCodes::try_from(*opcode).unwrap();
@@ -97,7 +102,7 @@ fn exec_program(instructions: Vec<(&str, &str)>, registers: &mut HashMap<&str, u
     out
 }
 
-fn parse_registers(input: &str) -> HashMap<&str, u32> {
+fn parse_registers(input: &str) -> HashMap<&str, u64> {
     let mut registers = HashMap::new();
     input.lines().for_each(|line| {
         let (register, value) = line.split_once(": ").unwrap();
@@ -121,11 +126,11 @@ enum OpCodes {
 }
 
 impl OpCodes {
-    fn exec(&self, operand: &str, registers: &mut HashMap<&str, u32>) -> Option<(u32, bool)> {
+    fn exec(&self, operand: &str, registers: &mut HashMap<&str, u64>) -> Option<(u64, bool)> {
         let a = *registers.get("A").unwrap();
         let b = *registers.get("B").unwrap();
         let c = *registers.get("C").unwrap();
-        let operand: u32 = operand.parse().unwrap();
+        let operand: u64 = operand.parse().unwrap();
         let combo = if operand <= 3 {
             operand
         } else if operand == 4 {
@@ -141,9 +146,9 @@ impl OpCodes {
             OpCodes::Adv => {
                 //println!(
                 //    "a = a / 2 ** combo = {a} / 2 ** {combo} = {}",
-                //    a / 2_u32.pow(combo)
+                //    a / 2_u64.pow(combo)
                 //);
-                registers.insert("A", a / 2_u32.pow(combo));
+                registers.insert("A", a / 2_u64.pow(combo as u32));
                 None
             }
             OpCodes::Bxl => {
@@ -177,17 +182,17 @@ impl OpCodes {
             OpCodes::Bdv => {
                 //println!(
                 //    "b = a / 2 ** combo = {a} / 2 ** {combo} = {}",
-                //    a / 2_u32.pow(combo)
+                //    a / 2_u64.pow(combo)
                 //);
-                registers.insert("B", a / 2_u32.pow(combo));
+                registers.insert("B", a / 2_u64.pow(combo as u32));
                 None
             }
             OpCodes::Cdv => {
                 //println!(
                 //    "c = a / 2 ** combo = {a} / 2 ** {combo} = {}",
-                //    a / 2_u32.pow(combo)
+                //    a / 2_u64.pow(combo)
                 //);
-                registers.insert("C", a / 2_u32.pow(combo));
+                registers.insert("C", a / 2_u64.pow(combo as u32));
                 None
             }
         }

y2024/src/days/d18.rs

@@ -0,0 +1,294 @@
+use std::{collections::HashSet, error::Error};
+
+use itertools::Itertools;
+
+pub fn process_part1(input: &str) -> u32 {
+    let falling_bytes = &input
+        .lines()
+        .map(|line| {
+            let (x, y) = line.split_once(",").unwrap();
+            (x.parse().unwrap(), y.parse().unwrap())
+        })
+        .collect_vec()[..1024];
+    let y_walls = vec![GridTile::Wall; 73];
+    let mut inner_rows = vec![GridTile::Path; 71];
+    inner_rows.insert(0, GridTile::Wall);
+    inner_rows.push(GridTile::Wall);
+    let mut grid = vec![inner_rows; 71];
+    grid.insert(0, y_walls.clone());
+    grid.push(y_walls);
+    simulate(grid, falling_bytes).unwrap()
+}
+
+fn simulate(mut grid: Vec<Vec<GridTile>>, falling_bytes: &[(usize, usize)]) -> Option<u32> {
+    grid[1][1] = GridTile::Start;
+    let height = grid.len();
+    let width = grid[0].len();
+    grid[height - 2][width - 2] = GridTile::End;
+    falling_bytes.iter().for_each(|(x, y)| {
+        grid[*y + 1][*x + 1] = GridTile::Wall;
+    });
+    let mut visited = HashSet::new();
+    visited.insert((1, 1));
+    let mut next_paths = vec![MazeRunner {
+        coords: (1, 1),
+        visited: visited.clone(),
+        ..Default::default()
+    }];
+    let mut arrived: Vec<MazeRunner> = Vec::new();
+    while !next_paths.is_empty() {
+        next_paths = next_paths
+            .iter()
+            .map(|maze_runner| {
+                let mut paths = Vec::new();
+                if let Some(path) = maze_runner.get_next(&grid, Direction::Up) {
+                    paths.push(path);
+                }
+                if let Some(path) = maze_runner.get_next(&grid, Direction::Down) {
+                    paths.push(path);
+                }
+                if let Some(path) = maze_runner.get_next(&grid, Direction::Left) {
+                    paths.push(path);
+                }
+                if let Some(path) = maze_runner.get_next(&grid, Direction::Right) {
+                    paths.push(path);
+                }
+                paths
+            })
+            .collect_vec()
+            .concat();
+        for (idx, maze_runner) in next_paths.clone().iter().enumerate().rev() {
+            if maze_runner.visited.contains(&maze_runner.coords)
+                || visited.contains(&maze_runner.coords)
+            {
+                next_paths.remove(idx);
+                continue;
+            }
+            visited.insert(maze_runner.coords);
+            next_paths[idx].visited.insert(maze_runner.coords);
+            if maze_runner.state == State::Arrived {
+                let arrived_reindeer = next_paths.remove(idx);
+                arrived.push(arrived_reindeer);
+            }
+        }
+    }
+    //let visited = arrived
+    //    .iter()
+    //    .map(|reindeer| {
+    //        reindeer
+    //            .visited
+    //            .iter()
+    //            .map(|(coords, _)| coords)
+    //            .collect_vec()
+    //    })
+    //    .collect_vec()
+    //    .concat();
+    //visited.iter().unique().count()
+    arrived.sort_by(|a_runner, b_runner| a_runner.visited.len().cmp(&b_runner.visited.len()));
+    if let Some(arrived) = arrived.first() {
+        log_maze(&grid, arrived);
+        Some(arrived.visited.len() as u32 - 1)
+    } else {
+        None
+    }
+}
+
+pub fn process_part2(input: &str) -> String {
+    let falling_bytes = &input
+        .lines()
+        .map(|line| {
+            let (x, y) = line.split_once(",").unwrap();
+            (x.parse::<usize>().unwrap(), y.parse::<usize>().unwrap())
+        })
+        .collect_vec();
+    let y_walls = vec![GridTile::Wall; 73];
+    let mut inner_rows = vec![GridTile::Path; 71];
+    inner_rows.insert(0, GridTile::Wall);
+    inner_rows.push(GridTile::Wall);
+    let mut grid = vec![inner_rows; 71];
+    grid.insert(0, y_walls.clone());
+    grid.push(y_walls);
+    let mut num_bytes = 1025;
+    while simulate(grid.clone(), &falling_bytes[..num_bytes]).is_some() {
+        num_bytes += 1;
+    }
+    let (x, y) = falling_bytes[num_bytes - 1];
+    format!("{x},{y}")
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+enum State {
+    #[default]
+    Going,
+    Arrived,
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+struct MazeRunner {
+    coords: (usize, usize),
+    visited: HashSet<(usize, usize)>,
+    state: State,
+}
+
+impl MazeRunner {
+    fn get_next(&self, grid: &[Vec<GridTile>], direction: Direction) -> Option<MazeRunner> {
+        let tile = match direction {
+            Direction::Up => grid[self.coords.1 - 1][self.coords.0],
+            Direction::Down => grid[self.coords.1 + 1][self.coords.0],
+            Direction::Right => grid[self.coords.1][self.coords.0 + 1],
+            Direction::Left => grid[self.coords.1][self.coords.0 - 1],
+        };
+        let coords = match direction {
+            Direction::Up => (self.coords.0, self.coords.1 - 1),
+            Direction::Down => (self.coords.0, self.coords.1 + 1),
+            Direction::Left => (self.coords.0 - 1, self.coords.1),
+            Direction::Right => (self.coords.0 + 1, self.coords.1),
+        };
+        if tile == GridTile::Wall {
+            None
+        } else if tile == GridTile::End {
+            Some(MazeRunner {
+                state: State::Arrived,
+                coords,
+                ..self.clone()
+            })
+        } else {
+            Some(MazeRunner {
+                coords,
+                ..self.clone()
+            })
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq)]
+enum GridTile {
+    Wall,
+    #[default]
+    Path,
+    Start,
+    End,
+}
+
+impl TryFrom<char> for GridTile {
+    type Error = Box<dyn Error>;
+
+    fn try_from(value: char) -> std::result::Result<GridTile, Box<dyn Error>> {
+        match value {
+            '#' => Ok(Self::Wall),
+            '.' => Ok(Self::Path),
+            'S' => Ok(Self::Start),
+            'E' => Ok(Self::End),
+            _ => Err(Box::from(format!("{value} is not a valid tile"))),
+        }
+    }
+}
+
+fn log_maze(grid: &[Vec<GridTile>], maze_runner: &MazeRunner) {
+    for (yidx, row) in grid.iter().enumerate() {
+        for (xidx, tile) in row.iter().enumerate() {
+            let contains = {
+                maze_runner.visited.contains(&(xidx, yidx))
+                    || maze_runner.visited.contains(&(xidx, yidx))
+                    || maze_runner.visited.contains(&(xidx, yidx))
+                    || maze_runner.visited.contains(&(xidx, yidx))
+            };
+            if contains && !(*tile == GridTile::Start || *tile == GridTile::End) {
+                print!("O");
+            } else if *tile == GridTile::Wall {
+                print!("#");
+            } else if *tile == GridTile::Path {
+                print!(".");
+            } else if *tile == GridTile::Start {
+                print!("S");
+            } else if *tile == GridTile::End {
+                print!("E");
+            }
+        }
+        println!();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INPUT: &str = "5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0";
+
+    #[test]
+    fn part1() {
+        let falling_bytes = &INPUT
+            .lines()
+            .map(|line| {
+                let (x, y) = line.split_once(",").unwrap();
+                (x.parse().unwrap(), y.parse().unwrap())
+            })
+            .collect_vec()[..12];
+        let y_walls = vec![GridTile::Wall; 9];
+        let mut inner_rows = vec![GridTile::Path; 7];
+        inner_rows.insert(0, GridTile::Wall);
+        inner_rows.push(GridTile::Wall);
+        let mut grid = vec![inner_rows; 7];
+        grid.insert(0, y_walls.clone());
+        grid.push(y_walls);
+        let result = simulate(grid, falling_bytes);
+        assert_eq!(result, Some(22));
+    }
+
+    #[test]
+    fn part2() {
+        let falling_bytes = INPUT
+            .lines()
+            .map(|line| {
+                let (x, y) = line.split_once(",").unwrap();
+                (x.parse::<usize>().unwrap(), y.parse::<usize>().unwrap())
+            })
+            .collect_vec();
+        let y_walls = vec![GridTile::Wall; 9];
+        let mut inner_rows = vec![GridTile::Path; 7];
+        inner_rows.insert(0, GridTile::Wall);
+        inner_rows.push(GridTile::Wall);
+        let mut grid = vec![inner_rows; 7];
+        grid.insert(0, y_walls.clone());
+        grid.push(y_walls);
+        let mut num_bytes = 12;
+        while simulate(grid.clone(), &falling_bytes[..num_bytes]).is_some() {
+            num_bytes += 1;
+        }
+        let (x, y) = falling_bytes[num_bytes - 1];
+        let result = format!("{x},{y}");
+        assert_eq!(result, "6,1".to_string());
+    }
+}

y2024/src/days/d19.rs

@@ -0,0 +1,96 @@
+use std::collections::HashMap;
+
+use itertools::Itertools;
+
+pub fn process_part1(input: &str) -> u64 {
+    let (patterns, designs) = input.split_once("\n\n").unwrap();
+    let patterns = patterns.split(", ").collect_vec();
+    designs
+        .lines()
+        .map(|design| {
+            if possible_design(design, &patterns) {
+                1
+            } else {
+                0
+            }
+        })
+        .sum()
+}
+
+fn possible_design(design: &str, patterns: &[&str]) -> bool {
+    for pattern in patterns {
+        if design.starts_with(pattern) && design.len() == pattern.len() {
+            return true;
+        } else if design.starts_with(pattern) {
+            if let Some(stripped) = design.strip_prefix(pattern) {
+                if possible_design(stripped, patterns) {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}
+
+fn possible_designs(design: &str, patterns: &[&str], memo: &mut HashMap<String, u64>) -> u64 {
+    if design.is_empty() {
+        return 0;
+    }
+    let mut num_possible_designs = 0;
+    if let Some(count) = memo.get(design) {
+        return *count;
+    }
+    for pattern in patterns {
+        if design == *pattern {
+            memo.insert(design.to_string(), 1);
+            num_possible_designs += 1;
+        }
+        if design.starts_with(pattern) {
+            if let Some(stripped) = design.strip_prefix(pattern) {
+                let for_stripped = possible_designs(stripped, patterns, memo);
+                memo.entry(stripped.to_string()).or_insert(for_stripped);
+                num_possible_designs += for_stripped;
+            }
+        }
+    }
+    memo.insert(design.to_string(), num_possible_designs);
+    num_possible_designs
+}
+
+pub fn process_part2(input: &str) -> u64 {
+    let (patterns, designs) = input.split_once("\n\n").unwrap();
+    let patterns = patterns.split(", ").collect_vec();
+    let mut memo = HashMap::new();
+    designs
+        .lines()
+        .map(|design| possible_designs(design, &patterns, &mut memo))
+        .sum()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INPUT: &str = "r, wr, b, g, bwu, rb, gb, br
+
+brwrr
+bggr
+gbbr
+rrbgbr
+ubwu
+bwurrg
+brgr
+bbrgwb";
+
+    #[test]
+    fn part1() {
+        let result = process_part1(INPUT);
+        assert_eq!(result, 6);
+    }
+
+    #[test]
+    fn part2() {
+        let result = process_part2(INPUT);
+        assert_eq!(result, 16);
+    }
+}

y2024/src/days/d20.rs

@@ -0,0 +1,232 @@
+use std::{
+    collections::{HashMap, HashSet},
+    error::Error,
+};
+
+use itertools::Itertools;
+
+pub fn process_part1(input: &str) -> u32 {
+    simulate_all(input, 100, 2).values().copied().sum()
+}
+
+pub fn process_part2(input: &str) -> u32 {
+    simulate_all(input, 100, 20).values().copied().sum()
+}
+
+fn simulate_all(input: &str, time_to_save: usize, max_cheat_time: usize) -> HashMap<u32, u32> {
+    let mut start = (0, 0);
+    let grid = input
+        .lines()
+        .enumerate()
+        .map(|(yidx, row)| {
+            row.chars()
+                .enumerate()
+                .map(|(xidx, chara)| {
+                    let tile = GridTile::try_from(chara).unwrap();
+                    if tile == GridTile::Start {
+                        start = (xidx, yidx);
+                    }
+                    tile
+                })
+                .collect_vec()
+        })
+        .collect_vec();
+    let no_cheat = simulate(&grid, start);
+    let mut saved = HashMap::new();
+    for (tile_idx, tile) in no_cheat[..no_cheat.len() - time_to_save].iter().enumerate() {
+        for (cheat_idx, cheat) in no_cheat[tile_idx..].iter().enumerate() {
+            let manhattan = tile.0.abs_diff(cheat.0) + tile.1.abs_diff(cheat.1);
+            if manhattan <= max_cheat_time {
+                let time_saved = cheat_idx - manhattan;
+                if time_saved >= time_to_save {
+                    saved
+                        .entry(time_saved as u32)
+                        .and_modify(|count| *count += 1)
+                        .or_insert(1);
+                }
+            }
+        }
+    }
+    saved
+}
+
+fn simulate(grid: &[Vec<GridTile>], start: (usize, usize)) -> Vec<(usize, usize)> {
+    let mut visited = HashSet::new();
+    visited.insert(start);
+    let mut next_paths = vec![MazeRunner {
+        coords: start,
+        visited: visited.clone(),
+        ..Default::default()
+    }];
+    let mut visited = Vec::new();
+    visited.push(start);
+    let mut arrived: Vec<MazeRunner> = Vec::new();
+    while !next_paths.is_empty() {
+        next_paths = next_paths
+            .iter()
+            .map(|maze_runner| {
+                let mut paths = Vec::new();
+                if let Some(path) = maze_runner.get_next(grid, Direction::Up) {
+                    paths.push(path);
+                }
+                if let Some(path) = maze_runner.get_next(grid, Direction::Down) {
+                    paths.push(path);
+                }
+                if let Some(path) = maze_runner.get_next(grid, Direction::Left) {
+                    paths.push(path);
+                }
+                if let Some(path) = maze_runner.get_next(grid, Direction::Right) {
+                    paths.push(path);
+                }
+                paths
+            })
+            .collect_vec()
+            .concat();
+        for (idx, maze_runner) in next_paths.clone().iter().enumerate().rev() {
+            if maze_runner.visited.contains(&maze_runner.coords)
+                || visited.contains(&maze_runner.coords)
+            {
+                next_paths.remove(idx);
+                continue;
+            }
+            visited.push(maze_runner.coords);
+            next_paths[idx].visited.insert(maze_runner.coords);
+            if maze_runner.state == State::Arrived {
+                let arrived_reindeer = next_paths.remove(idx);
+                arrived.push(arrived_reindeer);
+            }
+        }
+    }
+    visited
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+enum State {
+    #[default]
+    Going,
+    Arrived,
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+struct MazeRunner {
+    coords: (usize, usize),
+    visited: HashSet<(usize, usize)>,
+    state: State,
+}
+
+impl MazeRunner {
+    fn get_next(&self, grid: &[Vec<GridTile>], direction: Direction) -> Option<MazeRunner> {
+        let tile = match direction {
+            Direction::Up => grid[self.coords.1 - 1][self.coords.0],
+            Direction::Down => grid[self.coords.1 + 1][self.coords.0],
+            Direction::Right => grid[self.coords.1][self.coords.0 + 1],
+            Direction::Left => grid[self.coords.1][self.coords.0 - 1],
+        };
+        let coords = match direction {
+            Direction::Up => (self.coords.0, self.coords.1 - 1),
+            Direction::Down => (self.coords.0, self.coords.1 + 1),
+            Direction::Left => (self.coords.0 - 1, self.coords.1),
+            Direction::Right => (self.coords.0 + 1, self.coords.1),
+        };
+        if tile == GridTile::Wall {
+            None
+        } else if tile == GridTile::End {
+            Some(MazeRunner {
+                state: State::Arrived,
+                coords,
+                ..self.clone()
+            })
+        } else {
+            Some(MazeRunner {
+                coords,
+                ..self.clone()
+            })
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq)]
+enum GridTile {
+    Wall,
+    #[default]
+    Path,
+    Start,
+    End,
+}
+
+impl TryFrom<char> for GridTile {
+    type Error = Box<dyn Error>;
+
+    fn try_from(value: char) -> std::result::Result<GridTile, Box<dyn Error>> {
+        match value {
+            '#' => Ok(Self::Wall),
+            '.' => Ok(Self::Path),
+            'S' => Ok(Self::Start),
+            'E' => Ok(Self::End),
+            _ => Err(Box::from(format!("{value} is not a valid tile"))),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Instant;
+
+    use utils::time::get_elapsed_string;
+
+    use super::*;
+
+    const INPUT: &str = "###############
+#...#...#.....#
+#.#.#.#.#.###.#
+#S#...#.#.#...#
+#######.#.#.###
+#######.#.#...#
+#######.#.###.#
+###..E#...#...#
+###.#######.###
+#...###...#...#
+#.#####.#.###.#
+#.#...#.#.#...#
+#.#.#.#.#.#.###
+#...#...#...###
+###############";
+
+    #[test]
+    fn part1() {
+        let now = Instant::now();
+        println!("Test 2:");
+        let result = simulate_all(INPUT, 2, 2);
+        result
+            .iter()
+            .sorted_by(|a, b| a.0.cmp(b.0))
+            .for_each(|(saved, count)| {
+                println!("There are {count} cheats that saved {saved} picoseconds");
+            });
+        println!("Ran in {}", get_elapsed_string(now.elapsed()));
+        assert_eq!(result.values().copied().sum::<u32>(), 44);
+    }
+
+    #[test]
+    fn part2() {
+        let now = Instant::now();
+        println!("Test 2:");
+        let result = simulate_all(INPUT, 50, 20);
+        result
+            .iter()
+            .sorted_by(|a, b| a.0.cmp(b.0))
+            .for_each(|(saved, count)| {
+                println!("There are {count} cheats that saved {saved} picoseconds");
+            });
+        println!("Ran in {}", get_elapsed_string(now.elapsed()));
+        assert_eq!(result.values().copied().sum::<u32>(), 285);
+    }
+}

y2024/src/days/d21.rs

@@ -0,0 +1,344 @@
+use std::{char, collections::HashMap, error::Error, sync::mpsc};
+
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
+pub fn process_part1(input: &str) -> usize {
+    let mut memo = HashMap::new();
+    input
+        .lines()
+        .map(|line| {
+            let numpad = Numpad::from(line);
+            println!("first robot {}", numpad.sequence);
+            let _ = Numpad::revert_from(&numpad.sequence);
+            let keypad_1 = Keypad::from(numpad.sequence.as_str());
+            println!("second robot {}", keypad_1.sequence);
+            let _ = Keypad::revert_from(&keypad_1.sequence);
+            let keypad_2 = Keypad::from(keypad_1.sequence.as_str());
+            println!("me {}", keypad_2.sequence);
+            let _ = Keypad::revert_from(&keypad_2.sequence);
+            keypad_2.sequence.len() * numeric_part(line)
+        })
+        .sum()
+}
+
+fn extend_sequence(
+    sequence_parts: &[Vec<String>],
+    memo: &mut HashMap<(char, char), Vec<String>>,
+) -> Vec<Vec<String>> {
+    sequence_parts.iter().map(|possible_parts| {
+        let (tx, rx) = mpsc::channel();
+        let mut new_possible_parts = Vec::new();
+        possible_parts.par_iter().for_each(|part| {
+            let _ = tx.send();
+        });
+        drop(tx);
+        while let Ok(part) = rx.recv() {
+            new_possible_parts.extend_from_slice(part);
+        }
+        new_possible_parts
+    })
+}
+
+pub fn process_part2(input: &str) -> usize {
+    0
+}
+
+fn numeric_part(code: &str) -> usize {
+    let code = &code[..code.len() - 1];
+    code.parse().unwrap()
+}
+
+#[derive(Debug, Clone, Copy)]
+enum NumpadState {
+    Seven,
+    Eight,
+    Nine,
+    Four,
+    Five,
+    Six,
+    One,
+    Two,
+    Three,
+    Zero,
+    A,
+}
+
+impl NumpadState {
+    fn get_col(&self) -> i32 {
+        match self {
+            NumpadState::Seven | NumpadState::Four | NumpadState::One => 0,
+            NumpadState::Eight | NumpadState::Five | NumpadState::Two | NumpadState::Zero => 1,
+            NumpadState::Nine | NumpadState::Six | NumpadState::Three | NumpadState::A => 2,
+        }
+    }
+
+    fn get_row(&self) -> i32 {
+        match self {
+            NumpadState::Seven | NumpadState::Eight | NumpadState::Nine => 0,
+            NumpadState::Four | NumpadState::Five | NumpadState::Six => 1,
+            NumpadState::One | NumpadState::Two | NumpadState::Three => 2,
+            NumpadState::Zero | NumpadState::A => 3,
+        }
+    }
+
+    fn get_sequences(&self, goto: NumpadState) -> Vec<String> {
+        let row = self.get_row();
+        let col = self.get_col();
+        let goto_row = goto.get_row();
+        let goto_col = goto.get_col();
+        if row == goto_row && col == goto_col {
+            return vec!["A".to_string()];
+        }
+        let row_diff = row.abs_diff(goto_row);
+        let col_diff = col.abs_diff(goto_col);
+        let mut sequence = String::new();
+        let row_seq = match goto_row.cmp(&row) {
+            std::cmp::Ordering::Less => vec!["^"; row_diff as usize].join(""),
+            std::cmp::Ordering::Equal => "".to_string(),
+            std::cmp::Ordering::Greater => vec!["v"; row_diff as usize].join(""),
+        };
+        let col_seq = match goto_col.cmp(&col) {
+            std::cmp::Ordering::Less => vec!["<"; col_diff as usize].join(""),
+            std::cmp::Ordering::Equal => "".to_string(),
+            std::cmp::Ordering::Greater => vec![">"; col_diff as usize].join(""),
+        };
+        if (goto_col < col && row < 3) || col == 0 {
+            sequence.push_str(&col_seq);
+            sequence.push_str(&row_seq);
+        } else {
+            sequence.push_str(&row_seq);
+            sequence.push_str(&col_seq);
+        }
+        sequence.push('A');
+        sequence
+    }
+}
+
+impl TryFrom<char> for NumpadState {
+    type Error = Box<dyn Error>;
+
+    fn try_from(value: char) -> Result<Self, Self::Error> {
+        match value {
+            'A' => Ok(NumpadState::A),
+            '0' => Ok(NumpadState::Zero),
+            '1' => Ok(NumpadState::One),
+            '2' => Ok(NumpadState::Two),
+            '3' => Ok(NumpadState::Three),
+            '4' => Ok(NumpadState::Four),
+            '5' => Ok(NumpadState::Five),
+            '6' => Ok(NumpadState::Six),
+            '7' => Ok(NumpadState::Seven),
+            '8' => Ok(NumpadState::Eight),
+            '9' => Ok(NumpadState::Nine),
+            _ => Err(Box::from("Unrecognised keystate")),
+        }
+    }
+}
+
+impl TryFrom<(usize, usize)> for NumpadState {
+    type Error = Box<dyn Error>;
+
+    fn try_from(value: (usize, usize)) -> Result<Self, Self::Error> {
+        match value {
+            (2, 3) => Ok(NumpadState::A),
+            (1, 3) => Ok(NumpadState::Zero),
+            (0, 2) => Ok(NumpadState::One),
+            (1, 2) => Ok(NumpadState::Two),
+            (2, 2) => Ok(NumpadState::Three),
+            (0, 1) => Ok(NumpadState::Four),
+            (1, 1) => Ok(NumpadState::Five),
+            (2, 1) => Ok(NumpadState::Six),
+            (0, 0) => Ok(NumpadState::Seven),
+            (1, 0) => Ok(NumpadState::Eight),
+            (2, 0) => Ok(NumpadState::Nine),
+            (0, 3) => Err(Box::from("Robot arm hovering over numpad gap")),
+            (x, y) => {
+                let err = format!("Unrecognised numpad key coord ({x}, {y})");
+                Err(err.into())
+            }
+        }
+    }
+}
+
+impl From<NumpadState> for char {
+    fn from(value: NumpadState) -> Self {
+        match value {
+            NumpadState::Seven => '7',
+            NumpadState::Eight => '8',
+            NumpadState::Nine => '9',
+            NumpadState::Four => '4',
+            NumpadState::Five => '5',
+            NumpadState::Six => '6',
+            NumpadState::One => '1',
+            NumpadState::Two => '2',
+            NumpadState::Three => '3',
+            NumpadState::Zero => '0',
+            NumpadState::A => 'A',
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum KeypadState {
+    Up,
+    A,
+    Left,
+    Down,
+    Right,
+}
+
+impl KeypadState {
+    fn get_col(&self) -> i32 {
+        match self {
+            KeypadState::Left => 0,
+            KeypadState::Up | KeypadState::Down => 1,
+            KeypadState::A | KeypadState::Right => 2,
+        }
+    }
+
+    fn get_row(&self) -> i32 {
+        match self {
+            KeypadState::Up | KeypadState::A => 0,
+            KeypadState::Left | KeypadState::Down | KeypadState::Right => 1,
+        }
+    }
+
+    fn get_sequence(&self, goto: KeypadState) -> Vec<String> {
+        let row = self.get_row();
+        let col = self.get_col();
+        let goto_row = goto.get_row();
+        let goto_col = goto.get_col();
+        if row == goto_row && col == goto_col {
+            return vec!["A".to_string()];
+        }
+        let row_diff = row.abs_diff(goto_row);
+        let col_diff = col.abs_diff(goto_col);
+        let mut sequence = String::new();
+        let row_seq = match goto_row.cmp(&row) {
+            std::cmp::Ordering::Less => vec!["^"; row_diff as usize].join(""),
+            std::cmp::Ordering::Equal => "".to_string(),
+            std::cmp::Ordering::Greater => vec!["v"; row_diff as usize].join(""),
+        };
+        let col_seq = match goto_col.cmp(&col) {
+            std::cmp::Ordering::Less => vec!["<"; col_diff as usize].join(""),
+            std::cmp::Ordering::Equal => "".to_string(),
+            std::cmp::Ordering::Greater => vec![">"; col_diff as usize].join(""),
+        };
+        if (goto_col < col && row == 1) || col == 0 {
+            sequence.push_str(&col_seq);
+            sequence.push_str(&row_seq);
+        } else {
+            sequence.push_str(&row_seq);
+            sequence.push_str(&col_seq);
+        }
+        sequence.push('A');
+        sequence
+    }
+}
+
+impl TryFrom<char> for KeypadState {
+    type Error = Box<dyn Error>;
+
+    fn try_from(value: char) -> Result<Self, Self::Error> {
+        match value {
+            'A' => Ok(KeypadState::A),
+            '<' => Ok(KeypadState::Left),
+            '>' => Ok(KeypadState::Right),
+            'v' => Ok(KeypadState::Down),
+            '^' => Ok(KeypadState::Up),
+            _ => Err(Box::from("Unrecognised keystate")),
+        }
+    }
+}
+
+impl TryFrom<(usize, usize)> for KeypadState {
+    type Error = Box<dyn Error>;
+
+    fn try_from(value: (usize, usize)) -> Result<Self, Self::Error> {
+        match value {
+            (2, 0) => Ok(KeypadState::A),
+            (0, 1) => Ok(KeypadState::Left),
+            (2, 1) => Ok(KeypadState::Right),
+            (1, 1) => Ok(KeypadState::Down),
+            (1, 0) => Ok(KeypadState::Up),
+            (0, 0) => Err(Box::from("Robot arm hovering over keypad gap")),
+            (x, y) => {
+                let err = format!("Unrecognised key coord ({x}, {y})");
+                Err(err.into())
+            }
+        }
+    }
+}
+
+impl From<KeypadState> for char {
+    fn from(value: KeypadState) -> Self {
+        match value {
+            KeypadState::A => 'A',
+            KeypadState::Up => '^',
+            KeypadState::Left => '<',
+            KeypadState::Down => 'v',
+            KeypadState::Right => '>',
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const INPUT_1: &str = "029A";
+    const INPUT_2: &str = "980A";
+    const INPUT_3: &str = "179A";
+    const INPUT_4: &str = "456A";
+    const INPUT_5: &str = "379A";
+
+    const INPUT_1_BACK: &str =
+        "<vA<AA>>^AvAA<^A>A<v<A>>^AvA^A<vA>^A<v<A>^A>AAvA^A<v<A>A>^AAAvA<^A>A";
+    const INPUT_2_BACK: &str = "<v<A>>^AAAvA^A<vA<AA>>^AvAA<^A>A<v<A>A>^AAAvA<^A>A<vA>^A<A>A";
+    const INPUT_3_BACK: &str =
+        "<v<A>>^A<vA<A>>^AAvAA<^A>A<v<A>>^AAvA^A<vA>^AA<A>A<v<A>A>^AAAvA<^A>A";
+    const INPUT_4_BACK: &str = "<v<A>>^AA<vA<A>>^AAvAA<^A>A<vA>^A<A>A<vA>^A<A>A<v<A>A>^AAvA<^A>A";
+    const INPUT_5_BACK: &str = "<v<A>>^AvA^A<vA<AA>>^AAvA<^A>AAvA^A<vA>^AA<A>A<v<A>A>^AAAvA<^A>A";
+
+    #[test]
+    fn part1_full() {
+        let result = process_part1(&[INPUT_1, INPUT_2, INPUT_3, INPUT_4, INPUT_5].join("\n"));
+        assert_eq!(result, 126384);
+    }
+
+    #[test]
+    fn part1_1() {
+        let result = process_part1(INPUT_1);
+        assert_eq!(result, 29 * 68);
+    }
+
+    #[test]
+    fn part1_2() {
+        let result = process_part1(INPUT_2);
+        assert_eq!(result, 60 * 980);
+    }
+
+    #[test]
+    fn part1_3() {
+        let result = process_part1(INPUT_3);
+        assert_eq!(result, 68 * 179);
+    }
+
+    #[test]
+    fn part1_4() {
+        let result = process_part1(INPUT_4);
+        assert_eq!(result, 64 * 456);
+    }
+
+    #[test]
+    fn part1_5() {
+        let result = process_part1(INPUT_5);
+        assert_eq!(result, 64 * 379);
+    }
+
+    #[test]
+    fn part2() {
+        let result = process_part2(INPUT_1);
+        assert_eq!(result, 0);
+    }
+}

y2024/src/days/mod.rs

@@ -23,3 +23,11 @@ pub mod d15;
 pub mod d16;
 
 pub mod d17;
+
+pub mod d18;
+
+pub mod d19;
+
+pub mod d20;
+
+pub mod d21;