Restructure repo and update solutions to zig 0.10.1HEADmaster

8 files changed, 1031 insertions, 0 deletions

diff --git a/src/19/input b/src/19/input
new file mode 100644
index 0000000..f812951
--- /dev/null
+++ b/src/19/input
@@ -0,0 +1,573 @@
+29: 116 82 | 119 24
+45: 116 69 | 119 124
+24: 119 116
+79: 102 119 | 117 116
+52: 94 119 | 25 116
+116: "a"
+60: 48 116 | 27 119
+39: 119 41 | 116 132
+14: 119 119
+80: 116 116 | 119 134
+46: 119 14 | 116 61
+129: 30 116 | 61 119
+133: 119 2 | 116 122
+68: 119 3 | 116 33
+105: 119 47 | 116 104
+107: 62 119 | 50 116
+76: 119 100 | 116 127
+125: 119 111 | 116 86
+74: 24 119 | 61 116
+128: 119 76 | 116 99
+59: 87 119 | 7 116
+88: 62 116 | 50 119
+103: 119 97 | 116 118
+17: 116 119 | 119 116
+32: 116 134 | 119 116
+56: 119 106 | 116 60
+71: 115 119 | 10 116
+4: 119 118 | 116 61
+132: 119 17 | 116 97
+12: 67 116 | 78 119
+70: 119 24 | 116 30
+83: 17 116 | 30 119
+90: 116 105 | 119 12
+84: 119 87 | 116 14
+134: 116 | 119
+119: "b"
+49: 4 119 | 132 116
+50: 134 119 | 119 116
+99: 119 21 | 116 46
+48: 61 119 | 32 116
+54: 119 85 | 116 58
+122: 116 7 | 119 82
+53: 123 119 | 91 116
+75: 43 119 | 79 116
+66: 116 52 | 119 93
+13: 97 119 | 14 116
+23: 82 119 | 7 116
+95: 90 116 | 28 119
+98: 119 32 | 116 50
+118: 134 134
+2: 116 97 | 119 82
+62: 119 116 | 119 119
+89: 73 116 | 108 119
+96: 24 116 | 17 119
+131: 116 110 | 119 15
+123: 64 116 | 98 119
+78: 81 116 | 15 119
+0: 8 11
+87: 116 119
+18: 116 24
+41: 119 62 | 116 30
+28: 9 116 | 128 119
+33: 24 116 | 97 119
+58: 107 116 | 84 119
+20: 116 130 | 119 45
+109: 116 5 | 119 112
+55: 118 116 | 17 119
+11: 42 31
+30: 116 119 | 116 116
+104: 36 116 | 57 119
+67: 101 119 | 29 116
+106: 46 119 | 38 116
+10: 49 119 | 44 116
+121: 116 103 | 119 96
+111: 116 97 | 119 50
+92: 116 61 | 119 80
+35: 116 37 | 119 107
+26: 119 32 | 116 62
+64: 119 118 | 116 97
+86: 17 116 | 82 119
+130: 119 19 | 116 66
+25: 116 50
+110: 87 116 | 118 119
+61: 116 116
+1: 116 56 | 119 65
+40: 116 118 | 119 61
+22: 116 17 | 119 24
+63: 119 68 | 116 6
+94: 119 24 | 116 14
+100: 119 24 | 116 80
+3: 14 119 | 30 116
+81: 24 119 | 80 116
+126: 30 116 | 17 119
+7: 116 116 | 119 116
+44: 40 119 | 92 116
+16: 116 18 | 119 88
+102: 116 17 | 119 7
+51: 1 119 | 71 116
+5: 119 54 | 116 53
+124: 119 72 | 116 39
+108: 50 119 | 118 116
+65: 119 77 | 116 16
+114: 116 61 | 119 62
+15: 118 119 | 50 116
+19: 116 133 | 119 121
+21: 50 119 | 61 116
+101: 82 119 | 24 116
+31: 95 119 | 51 116
+115: 34 119 | 131 116
+117: 7 119 | 24 116
+27: 17 119 | 32 116
+6: 119 120 | 116 127
+85: 116 55 | 119 94
+93: 119 64 | 116 74
+69: 116 125 | 119 113
+47: 70 119 | 114 116
+42: 109 119 | 20 116
+72: 119 114 | 116 64
+82: 134 119 | 116 116
+9: 35 119 | 89 116
+112: 116 75 | 119 63
+36: 119 32 | 116 87
+57: 119 87 | 116 50
+38: 119 24 | 116 61
+77: 22 119 | 13 116
+91: 73 116 | 92 119
+8: 42
+113: 59 116 | 129 119
+97: 116 119 | 119 119
+73: 97 119 | 30 116
+37: 62 119 | 24 116
+120: 119 61 | 116 61
+34: 126 119 | 83 116
+127: 116 30 | 119 14
+43: 23 116 | 26 119
+
+babaaaabbbaaaabbbaaaaaba
+bababbaababaabbbabbaabaa
+aabbbbaaaaaabbbbaababaab
+bbaabbaabbaaaaabbbbbababbbaaabbababaaaababbbbaab
+baaaabaabaabbbbbbbbbaaba
+bbaabbaabbbbbbbbabbbabbbbbbabbbbaaabaabb
+babbaaaaaabaaaaabaabbabbbaabaaaababbbaaa
+aababbbbbbbbaaaabbabbaabaabbbaaaaababbaa
+bbbbbbbbbbbbaaababbaabbbbbbbbaaa
+bbbabbbbbbbabbaaaaaaabababaaaaab
+baababbbabbbabbbbaaabbbb
+baabbbbaaaabaabbabbbbbaa
+bbbabaabbaaaabbabaababaa
+aaaabaaaabababbbaabaabbbababaaaa
+baababaabbaababbbbbbaabb
+abababbababbababbbbabaaabbaababb
+abbaababaaaabaaabaaaaaab
+ababababababababbabaababbaabaabababbabbbbbabbabbbaabbaab
+aabbababbaaaaabaabaaaabb
+bbaaaaabaabbaabbaababaaa
+aaabbaaaaababbabaababaaabbbbabbababbbbbb
+bbbbbbbbabbababbabaaaaab
+bbabbaabbbbababbbabbbabaaabaaaabbabbbbaabbbababb
+aaabbaabbaaaabbabaabbbbaababababbabbbaabbaaaaaaaababbbaa
+baaabbbabaaaabaabaababbbbbaaaaabbaaaabab
+bbbbaaabbbbabbaaaabbabbaabbaaaabaaaaabaaaabaaaab
+ababaaabababaaabbbaaaabbbaaabbbabbbbaaba
+bbabbbbaaabaabbbbaaabbbabbaaaababbbbababbbaababb
+aaabbabbabbbabbbaabbbaabbbabbbaaaaabaaba
+baabbbbabaaaabaababbaaaabbbaababaaabaaaa
+ababbbbbaabbbabbbabaaabaaabbabbaaababbbbaaabaabbaaaababa
+aaaaabababbaababaaaaaabb
+abbabbabaabbbbabbabaaaaaababaaababbababaabababbbabababaa
+abaabbbbbbbbbbaababbabbbbababaababaaaaba
+abaabaabbbaaaababaaaabbb
+aabbaababbbaabbbabbaabaaabaabbabbbaabbba
+baabbbaaabbbbbababbabbbaaaabaabb
+aabbbbabbaabbabbababbababaabaaaaabbbaaab
+aaababbbbabbbabbaabbbabbaabababbabbbaaaabaababaa
+abbaaaaaabbaabababaabababaaaabab
+bbabbbaabaabbabaaabababbbaaaabaaababbbbbababbbaababbbaba
+babaabbaababbabaababbbababbaabbbaaaababbabbaabbabbaaaaaa
+abaabaaababaaababbbbbabaabbaaaaabbbabbbaabbbaabaaabaabba
+abaabaaabaaabbababaaaaab
+aaaabbbaabbbabbbbaababababababbbabaabababaaaabbababbbaba
+bbbabaaabbbbaaaaaaabbaaa
+abaabbaaabbbabaabbbaaaab
+aabababbabaabaabbbbbbbbbbbabbaba
+baabbababaabbabbaabaabba
+aabababbaaabbababaaabbabbabbabba
+abbabbbabaaaaabababaaabbbbbaababbabbbbbb
+baabbbbaabbaabaabaaabbbaabbabbbbabbbbabb
+aabbbabbababbaaaaabbabbaaaabaaab
+ababbaaabbbabbbaabaaaaaababbbbbb
+bbbabaabababbbabbbbbababbbababbb
+aabbbaabaabaaaaabbabbaaa
+aabaabbbbbaabbaabbaabaab
+bbabbbaaababbabaaaaababa
+bbbabbaabbabbbaabbababba
+bbbaaabaabababbbbbbbbbbaaaabbabbaababaaaaababaaaaababaaa
+abababbbbbbabbbbbaabbbab
+bbaaaaabaaaaabababbbbbba
+bbabaaaabbbbbbbbaaabbabaaabbbbbbabbbabaa
+aabbbbaaabaaabaaaababaaa
+ababababaabbbabaaababaab
+abbaaaaabababbaabbbaabbaaaabbbba
+bbbbababaaaabbaabbbbbaba
+ababbaabbbabbaabbbbbaaababbaaaabaabbabbaababbbbabaabaaab
+aabbbbaaaaaabbbbbbbbbbab
+aaaabaaaaaabbbbbbbbabbab
+babaaabbabbababbbbbababb
+abaabbbabbaaabbaaabbbbbb
+baaabbbabbbbaaaabbababbb
+abbaaaababbaabbbaaaaaaabaaaaaaabbbbbabababbbaaaa
+bbbaabaaaabbbbbbabbbaaabbaaaaaaa
+abbabaabbaaabaababaabaabbbbbaabb
+aaababbbabbaabaaabababbabbabaaabbbaabbba
+babaabbababaaabbabaabaaaabbbabaa
+bbaaabbabaaaabbaaaaaaaabbabbaaaaababaabb
+ababaabaababbbabababbaaaaaababba
+baabbbbaaabbababbaaababbbabbabbbbbaabaaa
+babbaaaaabbaaaababbbbbba
+bbbabaabaababbbbabaabaababaabaabbaabbaabbbabababbbbbbbab
+aaabbabaabbaabababaabaaabaaaabaabaaabaaabbaabbaaaaabaabbaabaabaa
+ababbaabbabaababbbbbbbbabaaabaababaabbaa
+bbaaaaabaabbbbbaababaabaaabbbaabbbabbabaaaaaabbbaaaabaab
+aaaaabaaaabbbabbbaabaabb
+aabbabbabababaababbbbabaaabbbbabbaabbbaababbbbba
+baaabbbabbbbababbbbabaaaaabbbbaabaaabaabaababbba
+abaaabbbbabbaaaabbabaaaabababaabbabaabaabaabaaaa
+abaaabaaaaabaaabababbbbaaabbbbbb
+abaabbaabaabbaabaababbab
+abaaaaaaabbaaaaababbabbbbbababbaabbabbbb
+bbbaaabaababaaabbaaababbabaabbbaaaabaaba
+babbabaaaababbabbbbabbbbbabbbbbabbaaabaababbbabbabbbaaaaaabababaaaaaabab
+aaabbabaabbaabbbbaaaabbb
+babaabbabbabbaabbaabababaabbbabbbbbbbaaababbaaba
+bbabbaabababaabaababbbabaaaaaaabbbbbbbaaabaababb
+aaaabaaaabbbbababaaaabbabbbbbbbbaababababaabaabb
+abaaabaaaabaaabbaabaabbbbaabbbab
+aaaaabaaaaababbbababaaaa
+aabbabbbaabbbbaaaabbbbaabbabbaabababbbbb
+aaabbbbabaaaabbbbbababbb
+abaaaaaabaababbbabaabbbaababbaabbbabbabaaaaabaab
+aabaaaaabbabaaaabaaaabbaaabbbbababaaaaba
+baaabaabaaabbabaabbaabaabbaaabaa
+bbabbbbabbbabaaaaaaababa
+aaaabaaababbabbbaaababab
+baabbbbbababbaabbbbbbbbabaababbbbbbababaabbaaabb
+baabbbbbaabbbabbabaabbbbabaaabba
+bbabaaabababbababbbbbbbbbabaaaaababaabab
+baaaabaaaaabaaabbbbbabbb
+babbabbbbbbbbbbbababababababaaababbbabbaaaaabbababaaabbb
+aaabbaabaabbbaaababbaaab
+aabbbabbbaaabaaaabbbabaa
+aabbbbaabbabaabaabaaaaab
+bbbaabbbabbababaababbbababaaaaaaaaaaabbb
+bababbaaababbaabbbbbbbbbaaaabbbbabaabbbaababababaababbabaabbbbbb
+aabbbaaaababababaaaabaaabaabbaaa
+ababbbbbbbbbbbbbabbbabbaababaabaabaaababbabababbbbbaaabbbbbbbaaaaabbbbab
+abbaaaaabbabbaababbaabbbbabaaaabbabbbaba
+babbabbbabbaabbababbbbba
+abbaabbbaabbabbbbbaabbaabbbaaabbbbbaabab
+ababaabbaaabbabbbbaaababbbaaabbabaaaaaab
+bbbababaaaaaaaabababababbababbba
+aaabbbbbbbbabaabbababbaababbababaabaabaa
+babaaaabbbaabbbbababbbbb
+bbbaabbbbabbabbbabbbbbabaaaabbaaaaaaaabaaabaaaab
+bbaabbbbbaabaabaaaaabbaaaabbabbaaaabaaabbbaabbbbabbbbabbbbbbbbabbbbaaaab
+baababbbabbabbabbababbba
+ababbabababaabbbababbbabaababaab
+baabababbbabaaabbaaabaaaaabbbabbabbbabbbbabaabaaaaaaabbaaaabaaaabbbaabaa
+abaabbbbaaaabaaaabbabbbaabbbabab
+aaaaabababbbabbbabbaaabaabbbababbbababbb
+bababbaaaababbbbababaaababbbabab
+bbbbbbbbbbbabbaaabaabaaaabbabababbbababb
+abbaababbbbaaabaaabbbbbaaabbbaaabbabaabbabbbbbbb
+abbaaaababbbbaaaabbabaabbaaaaaababbbabaa
+aabbbaabababbaabbbaababaabbbbabb
+babababaaabbbbbaabbababaabbbabbbbabbbaaabbbbaabbbbababba
+ababbaabbbaaaaababbaaabb
+aabbaabbaabbabbbbbbbaaabbbbbbbbaabaabbbaaaababbaabababaaaaabaabbababbabbaabbaaaa
+ababbbabbbabaaababbbabab
+bbaabbaaabbababbaabbbbaaabbbbaaaaaabaaabbabbaaabbbbbaababbbbaabaaaaabaab
+baaaabaabbbaabbaaaaaaaba
+baababbbbbbabbbabbbabbaabaaababbabbaaabaaabaaaab
+aabaaaaaabbabbbabaaaabab
+abbaaabaaabbaabababaababbbbbaababbbaaabb
+aabbbabbababbbbabababababbbbbaba
+aaabbabbbababaabbabaabbabababbaabbabbbbb
+abbbbbabbaabbbabbababaaabbbbbababbbbaaaaaabaaabbbabaabbbbbbabaaaabbabbbabbabaaaa
+aabbaababbaaaaabaaabbbba
+aabaabbbabbbabbaabbabbaa
+bbaaaaababababbbababbbababbbabbbabbbaaabbaaaaaaabaabaaab
+babababaabbaabbabbbaabbbbaaabbbb
+babaaaaababaabbbbabaababbbabbaabbbaabbaabbabbbaaaaaabbabbbbbaabb
+aaababbbabbaabaaaaabbabaaaaaabbbbbbabbab
+aabbababaabbbaaabbbabaabbbaababaaabaabbbababbabb
+babbaaaabaaaabbabaabbbbaaabbaabaabababaa
+abababbaaababbbbbaabbabaabbbbabb
+bbbabaabababaababbbbbbaa
+bbbbabababbbbaaabbaaaabaaaaabbbabbbbbabb
+aabaabbbbbabaaaabbaaaabbababaabbaaababba
+babaaaabbbbbbbaababaabbabbbabababbbbaaba
+ababababaabbbbbabbaaabbb
+babbabbbbbbabaaabbababbb
+babbbabbababaaababaaaaab
+abaabbbbabbaabababbbaaaa
+bbbabaabbaaababbabbaababbaaaaabaaabbabaabbbbbaaa
+aababbaaababaabbaaabbbabbababbaaaabaaaaabbababbaabbaaabbbabaabba
+bbabaabaaabaaabbbabaabba
+aabbbaabaababbbbbaababbababbbbbbbaaabbbb
+aaabbababbaababaaabbbbaababbbbaaabbbaabb
+babaabbbababbbabbbbbbbbbbbabbaabaaababba
+bbabaaabbbaabaaaaababbba
+baaababbabbaabbabaaabbabaabbabaa
+bbabaaaaaaabbabababaaabaaabbaabbababbaababbabbabbababbabbbababba
+baaabbbbaaaaabaabababababbaababbbbabbbababaaabbbabbaabbb
+bbbabaaaaabababbaaabbaabbaabaaabaabbabaa
+bbaaaabaaaabaabbaaabaabbabbbbbbabbababbaaabbaaabbaabbaab
+babbaaaaaaabbaabbbbbabaa
+bbaabbaaabbbbbabaaaababb
+aabbbbbabbbababababbbabbbaaabbbabaabbaabaaababba
+abaaaabaabbabaaaaaaabbabbbbaababbabaabbbbbbaaababbababab
+abbbbaaaaaaabbaabaabaababaabaabaabbbabbaaabbabaabbaababb
+bbbbbbaabbaababababaaabbbbabbaaa
+babaaabbbaaaaabaabaabaaabbbbbbbabbbbbabb
+aaabbaabbbabbaabbbbabbbbaababababbbbbaaa
+bbbabaabababbbabbaaabbabbaabbabbabbaaababbbbbaabaaabbbbabbbaaabbbabbbaab
+ababbbbabaabababbbabaaaabbbaabbabbababaabbababba
+bbabaaaaaaabbabbbabbaabb
+ababaababbbbbbbaaaabaaba
+bbbabbbbaaaababbbbaaaaaa
+bbbababaaabaababbbbabbbbaabababbbabbababbaaaaaaaaaabbbaabaaabbaa
+abaabaabbbaaaababbaaabaa
+babbabbbbabaababaaaaabaaaaaabaaaabbaaaabaabaabba
+bababbbbaabbaababbabbaabbaababbaabbbaabbaaabbbaa
+bbbbbbaabbaaaabbabaabaaaaababaab
+bbaabaabbaaaaabbababaabbbbbabbaababbaaaababbaabbaabaabaabbabbaabbbababab
+bbbabbbabbaabbaabaaabbaa
+bbbabbbabaaaabaaabbbbbbb
+aabbbabababbaaaaabababbbabbbaaab
+baaababbabbbabbbbbaabbbbbbbaabab
+aaaabbaaababbaabbbababaa
+bbaaaabbbaaababbabbbbabb
+babaaabaababababaabbabbaaaabaabbabaaaaab
+baaabaabababaabaaaabaaabaabaabaa
+abbababbbbbbababbaababbabbaabbbaabbabbbb
+aaaaaaabaabaababbbabbbbababaaaaabbbaabab
+baabbbbbabaabababbaababaababbbabababaabbabbbbbba
+aabbabbaabbaaaaaabbbaaaa
+aaaabbbbbaabababbabbabbbababbbbb
+babaababbbaabbbbabbaaababaabababbaaabbbbababaabb
+babbababbaaaaabaaabaaabbababbaab
+bbaabbaaaabbbbabaaabbbbbbaaababa
+abbbabbabaabaababaabababbbbbbbaaababbabbbbabbaaa
+aabaaaaaaabbaabbaabbaaab
+aabaaaaabaaaaabbaaaabbab
+ababaabaabbbbaaabbbbaabb
+abbaabbbbbbbaaabbaabbbbbbbaabbaaabaabaaaabaaabaabbbbbabbbbababbb
+babaabbabaabaabaabbaabbabaaabbaa
+bbaabababababbbbbbaabbab
+aabbbbaababaaabaaaaaabba
+aaabbbbbabaababaabaabaababbabaabbaaaaaaa
+bbaababaaaabaaabaabbabababababbbabbaaaabaaaaaaaaaabaabaaaabbaaabbaaabbaa
+aabbbbbaaabaaabbbbbaabaa
+abbbaabbaaabbabaabbbababaaaaabbaabaabaabbbbaababababaabaaabaabbabbaabbbbbbbbbbabbabbaaaa
+baaabaaaabbaabbaabababbbaabaaabbabbaabbaabbababaaaababab
+aaaaaaabbbabbbaaababbbabaaabbbaa
+baaaaabaabaabababbbaabbb
+aababbbbbbaaaabbaabbbbabaaaabbbabbbbabbb
+baaaabaabbbabaaaaabaaaba
+bbbaaabaababaaababbbabaa
+bbaaaabbbbbaaabaaabbbaaaaaabbabbbbbbbaab
+baaaabaabaabbabaaaabbbbbaaaabaaababbaaaabababbbabaabbbabbababbab
+ababbbaabbabaabaabaabbbbababbaababbababbabbaaabbabbaaaaaabaabbaaabbaaaaaaabaabbb
+ababaaabbaabbabaabaabbbbabaaabaaaababbab
+baaabaabbabbaaaabbbbbbaabbbbaabb
+bbabaaaaaaabbbbbabbabbbaabbaaababbababba
+bbbbaaaaabbaababbabbbaaa
+bbbbbbbbaababbbbaababaab
+aaaaabaabbabbbaabbabaaaaababbababbaaaababaabaabaaaaabbab
+babaaaaababbbabbbbaabbaaabbbaaab
+bbaaaababbbaabbabaaabbbb
+baabbabbbbaabbbbaabbbbbb
+aabbaababbaabbbbbaaababbaabaaaba
+aaaabbbaababbaabaaabbbaa
+bbbaabbbbabbababbaabbabaaabaabbabbabbaaa
+abaababaabaaabaaaabaabababaaaaaaababaaabbabababb
+bababababaaaaabbaaaaababbbbabbbabababaabbabbbaab
+abbaabbbaabaababababbbbb
+babaaaabababbababbaaaababaaaaababbbbbbbabbbaaabbaaabaaaa
+aabbaabbbabaaaaabaabaaab
+aabbbaabbabbabbbbaaababa
+baaaaabbabbaababbaabbabbaaabbbaaabaabbab
+ababaababbaabbaaabbbbabaaaaabbaaaababbabbbabbaba
+aaaaabaaaabbbabbaabbaaaa
+abbaaabababaabbaabaaaaab
+abaaabaaaabbbababbbbbaaa
+bbbbbbaabababbaabbbbbbaababbbaab
+bababaabbaababbbbaabbababbbaaabababbaaaaaaabbbab
+bbbbaabaaaabababbaabbbab
+abaabbbbaabaaaaaabbaaabababbbbbbaaaaaaaa
+abbaabbaaaaabbbbbabaaabababbbbba
+aabbaabbababababbaaababbabbabbabaabaaaba
+bbaaaabbababbbabaabbbbbababbbbaaaaabaaaa
+abababbaababbbbaaababbbbababaaaabbbaaaab
+abbabbababbaaaababbaabbbbabbbbbb
+abbbbbababaabbbabbaaaaabaaaaabbb
+abbaabbbbaaabbabbabbabbbabbabbbaaabbababbbbbabaabaababaa
+aabbbaaabaabababbababbbbabbbbbaa
+bbbaabbbaabbbaaabbaaaaabbaabaabaaaababbbabbabbbaaabbaaaa
+baaaabbabaabbabbaaaabbbaaaaaabaabbaaaaabbabbbbba
+aabbabababababbababababaababbbbababbaaba
+ababbbbaabbabbbabaaaabab
+aababaaaaaaabbabbabbaaba
+bbaaaaabbabaabbaaaaabbaa
+aabaaaaabaaabbbaaaabbabababbbbbb
+abbababbaabbbaaababbababaaaaababbbaabbbbbabaaaaaabaaaabb
+baababbaabbaaaababbabaaa
+abaaaaaababbbabbaabbbbaabbbabbaaabbabbbaabbbbbabaaabaaaabbaabaabaaabbaaabbbaababbaababaa
+bbbabbbbabbbabbabaabbababbaabaaaaabaaaab
+abbaabbbbbabbbbabaaabbaa
+bbbaabbaabbabaabaaabaaba
+babbabababababbabababaaa
+abababbbbbbabbbbababbbaa
+aaababbbabbaaaaaaababaab
+aaaabbaabaaaabaabbbababababaaabaabbabaabababbabb
+ababbbabbaaabbabbbaaaaaa
+abbaaabaaababbbaaabababbbbbbbabb
+bbbbbbbaababababababbabaabaabbaa
+abababbbbaababbbaabbbabbbbabbaba
+baabababaabbbaabbabaaabbbaabaaaaabbbbbbb
+aabbbbaababaaababaaababa
+bbabbbaababaaabbabbbbbaa
+ababbbababbbbaaabbbaabaa
+baaaabaaabababbbaaababba
+bbbabbbababaaaabaababaaa
+babbabbbaaabaaabbbabaabaaaaaabbb
+ababaaababbaabaaaabbbbbaabbbbaaaaaabaabaaaaabbab
+bbbabaaababbaaaababbababaaaaabbabbbbbaba
+babaabbabaabbabaaababbbbababababbaabbbaaaaabaaba
+baabbbbaaabaababaaaabaaaaaaabaab
+abbbabbaababbaaaaabbaabababbbabbaababbabbbbabbaaabbaaaabbbbbbabb
+bbaabbbbaaababbbbaaabaaabaaabbbaabbbbaabbaabbabbabababababbbbbaababbabbbaaaababb
+abbaabbabbbabbbaaabbabbaaaabaaabaabaaaba
+bbbabaabaabaabbbbabbaaba
+abbababbbbabaabababaabaa
+aabbbabbbbabaaabbabababbbbbaabaaabaababbbbbabbaa
+babaabbaababbaaaaaaabababbbbabaa
+abbabaabbbbbbbbbbaabbbbbabababbaaababbba
+ababaababbaabbaabbaaaaabbaaaabaaabbbbaabaaabaabb
+bbabbbaabbaabbaabaabbbbabaabbaaa
+abaabbbbaabbaabbbbbabaaaabbaaabababbbaba
+bbaaaabbbabbbbabbbbbabbababbbbbaabbbabab
+ababbbbabbabaabababbbbab
+abababbaaaabbabbaaaabbbb
+abaabbbaabbaaaaabababaabbaaaaabababbbbaabaaaaaab
+abbaaaaaababbaabbbbbbaaa
+bbbabaabbabaabbbababababbaabbaababababaa
+abbabbabbaabbbbaabbaabbabbbbbbababbbbaab
+bbbbbbbababababaaabaabaa
+bbabbbbabaabbababbababaa
+abababaabbababbbbbabbabaabbbaaabaaaabbbabaaaaaabababaabbabbabaabaaabbabb
+bbaaaabbbababbbbaaabaaabbaabbbaabbbaabbabbbaaaaababbbbabbabbaabb
+aabbbbabaaaabbbabaababab
+babaabbabbabaabaaaaaaaabbbaababb
+aabbbaabbabaaabbaaabaaabbabbaabb
+aabaaabbbbabaaaabbbabbaaababbbabbbbbbbbabaabaaaa
+ababaabaabbaabaaabbababbababaabbabaaaabaaabaabaaaaabbbaa
+babaaaaaaabbbaabbabaabbbbbaaaabbababaaaabbbaabab
+babababaaaaaababbbabbaabababaaabbabbbbba
+abbbbaaaababbaaaababbbbb
+abababbaaaaaaaabbaaabaabaaababab
+aabbbabbbbbaabbbaaababab
+aabbbbabbbaabbbbaababbbbbbbaabaa
+bbaabbaababaaaaabbaaaaaa
+bababbaaabaabbaabbbbbabbbbabaabaababaaaabbbabbbabbabbbbaaaaaabbabaabbabaabaaaaabbbbabbbb
+bbbaabbabbabbbbaaaababba
+bababbaaaaabaaabbbbbbabb
+ababbaabbaaaabbaabbaabbbbaaaabbb
+babaabbababaaaaababbaabb
+aaabbbbbbbabbbaabbbbbaaa
+abaabaaaabbaababbaabaabb
+aabbabbbbabaaabbabbabbbabbabbbbabbbabaabaababaab
+abaabaabbababaababbbbbaa
+aababbbbbbaaaaaaabbaaaaaaabababaababaaaaaababbababbbbabababaabab
+abbabbababbbbaaabaaabaabaaabbbba
+aababbbbbbbabaabaabbaaaa
+aabbbaabbaabbabbbaaababaaabababaabbaaaababaaababaabbbabbbbbbaababbaababb
+aabbaabbbaabbababbabaabaabbbabbabaaaaaaa
+babaaabbaabbbbaaaabbbbabaaababbaabaaabba
+babaaababbaababaabaaabbb
+bbabaaaaababbaaaaababbbbbaaaaaab
+aaaabbbbbbaaabbababbaaba
+abbaabbaaabbbaabbbbaabab
+abaabbbaaabbbaaabbababababbbbbbb
+bbabbaababbaabbabbabbbbb
+abbaabababababbaaabbaaab
+aaaaaaabaabababbabbaababbabbabbbbabababbbbbbbabbaaaaaaaa
+abaabbbbbbbaabbaababbabb
+baabaababbabaababaabaaaabbabbabbabbbbaab
+bababbaaaaaabbbaaaabbabbaababbaa
+babaaaaaaabaaaaaaababababababbab
+bbaababaaabbbaababbaabbbaabbaababaaaaabaabaababb
+aabaabbbbaabbababbaabbbbabaaabaabbabbbaaabbbaabb
+abaabbbbbaaabbbababbbabbbbaaaabbbaabaabbbbaabaaa
+aabaaaaaaabababbbbbbbaba
+abbaababababbaabbbbaabbbababaaaababbbaab
+bbaaabbababaabbbaababaaa
+abbbabbbaabbabbabababababbaaabaa
+baabbbbabbabbbaabbaaaaababaaaabb
+abaabbbaaabbabababbbbbabbbbabaaabbbabbbaaababbaa
+aabaababbabaaabbbbabbbaaaabbbbbbaababaab
+abbaaabbaababbabbbbaaaabbbbabbab
+aaabbabaaabbbaaaabaaabaaaaabbbbbaaaabbbbaabbaaaa
+babbbabbabaabaabaabaaaaaababbabababaabbbaaababbaababbbbb
+aaaabbaabbbabbbaabbbaabb
+aabababbabbabbbabbbbaaabbbbbaabb
+aabaaabbabababbbaabbbaaaaababbbbaaaaabaaaaabaabb
+aabbababababbaaabaabbaaabbbaaaaababbbaabbababaaaabaabbaabbbabaab
+bbbabaabaabbbaaaababababbbaabaaa
+bbbbbbaaaaabbabaabbbabaa
+aaaaabbbababbbaabaaaabbbabaaababaaababbbaaaabaaa
+aabbbabbabbbbabaaaabbbbbababbbababbbbababbbbbaba
+ababaaabbbabaaababababbbabbabbaa
+abbaabbababaaaabbabaaaaabbabbbbaaaabaaaaabaaabba
+abbaababaabaaabbbbbbabaa
+aaabaaabaaabaaabaaaabaaabbbbaaaaaabbababbbbaabaabbbbaaba
+ababaabaabaababaaaabbaababbbaaba
+aabbbbabbbaaaabaabaabaabbbaabbab
+aabbbbaababaabbababbbaba
+aaabbaabababbbabbbbbaaabbbaabaababaabbaa
+babababaababbbabbaababbabbaaabaaabaaaaab
+aaaabbbaaabbaabbaaaaabba
+bbaaabaababaaaaabbbaabbbbabaaabbaaabbbbaaabbbabbbbbbabbb
+abbbabbbbababbaabbaabababbbbbaba
+babbaaaaabababbbbaabababbbbaabab
+baaabaaaababaaabaababbbbababababbabaaabaabaaaabaaaabaaaa
+baaabbababbbbbabbabaabbabaaababbbbbbbbbbabbabbbbaaaababa
+ababbaabaaabbabbabbabbbb
+aabbababaaaababbbbabbbbb
+babaaababbabaaaababaababbbaaabbababaaabaabbbbabb
+bbaaabbbabaaaabbbaaaaaab
+aabaaaaabbaaaabbabbaaababbaabbbbbaabbbaaaaaaabba
+baabababaabababbaaaaaaaa
+abbbaabaaabbaabbbaabbbbabaaabbbbbaaaaabaaababbbaabbababb
+aaabbabbbababaabaabbaabaabbabbbaaabbbaaabbabaaaaaababbbaaababbabbaabbaaabbabaabb
+ababaaabbbabaaaabaabbbaababaabbbbbaaaabbbabaabbbabbbbbbabbaabbabaaababbabbbbaabb
+bbbbbbbbbaabaabababbbaaa
+bbaabbaaabbabbbababbabaa
+abbaabaabbbbabbabbbaabababbbabaaabbbbabbbbbabaabbbabbbbabaaaabbbbabbababaababbba
+aaabaaaaabababbaabaaababaababbabababbbaaaabbaaaabbabaabaaababbaababbabbabbaaaaba
+aabababbabaabbbbbbbbaabb
+babaabbbbaabbababaaabaaaaabaaabbaababbaa
+aaabbbbbaaaabaaaababbbbabaabaaaaaaaabaab
+aabbaabbaabababababbbbba
+abbbabbabaabbabbbaaaabab
+bbabaaaabbbababababaabababbaababbaaaababbabababbabaabbab
+babaabbbaabaabbbabaabbbaaaababbbbabbaaababbbaabaabaaaaab
+aabbaabaabbaabaaaabbbbaabbaabaaa
+aaabbaababbaaaaaabbbbababaaaabbbabaabbab
+bbaabbbbabaababaababbaabbaaabbbaaaaabaaaabbabbbb
+baaaabaabbabbbbaaaabbabbbababbbbbbababab
+ababbaababbaabaaabaabaababaaaabbaaababab
+bbbbaaaaaabbbbabbaabaaab
+aabbbabababbabbbaababaaa
+baaababbbaababbaabaaabaaaabbabbabbababbb
+aabaababbabaaaabbabaaabaaaaaaabababbbbaa
+abbabbabaabaaaaaaaaabbbbbaabaabaaabbaabbabaaabbaaabaaaababaaabbaabaaabbb
+baababbabaabaababaaaaaab
+baaaabaaaaaababbabbabbbabbabaabb
+bbaaabbaabaabaaaabbababaaabbbbabbabbbbaa
+abababbaababbbbababababababababaabaaabba
+aabaabababbaabbabbababbb
+aabbbbabbabaababaaababab
+bbabbbbbbaabbbbaabbbbabbabaaaababaabbbbb
diff --git a/src/19/input-test b/src/19/input-test
new file mode 100644
index 0000000..1500b6f
--- /dev/null
+++ b/src/19/input-test
@@ -0,0 +1,12 @@
+0: 4 1 5
+1: 2 3 | 3 2
+2: 4 4 | 5 5
+3: 4 5 | 5 4
+4: "a"
+5: "b"
+
+ababbb
+bababa
+abbbab
+aaabbb
+aaaabbb
diff --git a/src/19/input-test2 b/src/19/input-test2
new file mode 100644
index 0000000..04b5e07
--- /dev/null
+++ b/src/19/input-test2
@@ -0,0 +1,9 @@
+0: 4 1 | 5 0 1
+1: "c"
+4: "a"
+5: "b"
+
+ac
+acb
+aaabbb
+b
diff --git a/src/19/input-test3 b/src/19/input-test3
new file mode 100644
index 0000000..8c931b1
--- /dev/null
+++ b/src/19/input-test3
@@ -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
diff --git a/src/19/main.zig b/src/19/main.zig
new file mode 100644
index 0000000..56c01d4
--- /dev/null
+++ b/src/19/main.zig
@@ -0,0 +1,181 @@
+const std = @import("std");
+const aoc = @import("aoc");
+
+const Rule = union(enum) {
+    c: u8,
+    combos: []const []const usize,
+};
+
+fn printSlice(slice: []const usize) void {
+    for (slice) |v, i| {
+        if (i > 0) {
+            aoc.debugfmt(" ", .{});
+        }
+        aoc.debugfmt("{}", .{v});
+    }
+}
+
+var stacktrace: std.ArrayList(usize) = undefined;
+
+fn checkRule(rules: *std.AutoHashMap(usize, Rule), rid: usize, msg: []const u8, nextstack: *std.ArrayList(usize)) anyerror!bool {
+    if (msg.len == 0) return true;
+    const rule = rules.get(rid) orelse return aoc.Error.InvalidInput;
+
+    if (rule == .c) {
+        if (msg[0] != rule.c) return false;
+        if (msg.len == 1) return (nextstack.items.len == 0);
+        if (nextstack.items.len == 0) return false;
+
+        const next = nextstack.pop();
+
+        const valid = try checkRule(rules, next, msg[1..], nextstack);
+        if (valid) try stacktrace.append(next);
+        if (valid) return true;
+
+        try nextstack.append(next);
+    } else {
+        for (rule.combos) |ruleseq| {
+            try nextstack.appendSlice(ruleseq[1..]);
+            std.mem.reverse(usize, nextstack.items[nextstack.items.len - (ruleseq.len - 1) ..]);
+
+            const valid = try checkRule(rules, ruleseq[0], msg, nextstack);
+            if (valid) try stacktrace.append(ruleseq[0]);
+            if (valid) return true;
+
+            try nextstack.resize(nextstack.items.len - (ruleseq.len - 1));
+        }
+    }
+    return false;
+}
+
+fn freeRules(allocator: std.mem.Allocator, rules: *std.AutoHashMap(usize, Rule), ignore: ?[]const usize) void {
+    var mapit = rules.iterator();
+    while (mapit.next()) |kv| {
+        if (ignore != null and std.mem.indexOfScalar(usize, ignore.?, kv.key_ptr.*) != null) continue;
+        if (kv.value_ptr.* == .combos) {
+            for (kv.value_ptr.combos) |rs| {
+                allocator.free(rs);
+            }
+            allocator.free(kv.value_ptr.combos);
+        }
+    }
+    rules.deinit();
+}
+
+fn parseRule(allocator: std.mem.Allocator, rules: *std.AutoHashMap(usize, Rule), line: []const u8) !void {
+    const indexsep = try aoc.unwrap(std.mem.indexOf(u8, line, ": "));
+    const index = try std.fmt.parseInt(usize, line[0..indexsep], 10);
+
+    var chrsep = std.mem.indexOf(u8, line, "\"");
+    if (chrsep != null) {
+        if (chrsep.? == line.len - 1) return aoc.Error.InvalidInput;
+        try rules.put(index, Rule{ .c = line[chrsep.? + 1] });
+    } else {
+        var vals = std.ArrayList([]usize).init(allocator);
+        errdefer vals.deinit();
+
+        var ruleit = std.mem.split(u8, line[indexsep + 2 ..], " | ");
+        while (ruleit.next()) |r| {
+            var ruleids = std.ArrayList(usize).init(allocator);
+            errdefer ruleids.deinit();
+
+            var spaceit = std.mem.tokenize(u8, r, " ");
+            while (spaceit.next()) |word| {
+                try ruleids.append(try std.fmt.parseInt(usize, word, 10));
+            }
+
+            if (ruleids.items.len == 0) return aoc.Error.InvalidInput;
+
+            try vals.append(ruleids.items);
+        }
+
+        try rules.put(index, Rule{ .combos = vals.items });
+    }
+}
+
+fn part1(allocator: std.mem.Allocator, input: []u8, args: [][]u8) !?[]u8 {
+    _ = args;
+
+    var rules = std.AutoHashMap(usize, Rule).init(allocator);
+    defer freeRules(allocator, &rules, null);
+
+    var partit = std.mem.split(u8, input, "\n\n");
+
+    var lineit = std.mem.tokenize(u8, try aoc.unwrap(partit.next()), "\n");
+    while (lineit.next()) |line| {
+        try parseRule(allocator, &rules, line);
+    }
+
+    var answer: u32 = 0;
+    var nextstack = std.ArrayList(usize).init(allocator);
+    defer nextstack.deinit();
+
+    stacktrace = std.ArrayList(usize).init(allocator);
+    defer stacktrace.deinit();
+
+    lineit = std.mem.tokenize(u8, try aoc.unwrap(partit.next()), "\n");
+    var count: usize = 0;
+    while (lineit.next()) |line| {
+        count += 1;
+        if (try checkRule(&rules, 0, line, &nextstack))
+            answer += 1;
+        try nextstack.resize(0);
+    }
+
+    return try std.fmt.allocPrint(allocator, "{}", .{answer});
+}
+
+fn part2(allocator: std.mem.Allocator, input: []u8, args: [][]u8) !?[]u8 {
+    _ = args;
+
+    var rules = std.AutoHashMap(usize, Rule).init(allocator);
+    defer freeRules(allocator, &rules, ([_]usize{ 8, 11 })[0..]);
+
+    var partit = std.mem.split(u8, input, "\n\n");
+
+    var lineit = std.mem.tokenize(u8, try aoc.unwrap(partit.next()), "\n");
+    while (lineit.next()) |line| {
+        if (std.mem.eql(u8, line[0..2], "8:")) {
+            const p1: []const usize = ([_]usize{42})[0..];
+            const p2: []const usize = ([_]usize{ 42, 8 })[0..];
+            try rules.put(8, Rule{ .combos = ([_][]const usize{ p1, p2 })[0..] });
+        } else if (std.mem.eql(u8, line[0..3], "11:")) {
+            const p1: []const usize = ([_]usize{ 42, 31 })[0..];
+            const p2: []const usize = ([_]usize{ 42, 11, 31 })[0..];
+            try rules.put(11, Rule{ .combos = ([_][]const usize{ p1, p2 })[0..] });
+        } else {
+            try parseRule(allocator, &rules, line);
+        }
+    }
+
+    var answer: u32 = 0;
+    var nextstack = std.ArrayList(usize).init(allocator);
+    defer nextstack.deinit();
+
+    stacktrace = std.ArrayList(usize).init(allocator);
+    defer stacktrace.deinit();
+
+    var count: usize = 0;
+    lineit = std.mem.tokenize(u8, try aoc.unwrap(partit.next()), "\n");
+    while (lineit.next()) |line| {
+        count += 1;
+        const valid = try checkRule(&rules, 0, line, &nextstack);
+        answer += @boolToInt(valid);
+        if (aoc.debug) {
+            aoc.debugfmt("TRACE: [", .{});
+            std.mem.reverse(usize, stacktrace.items);
+            printSlice(stacktrace.items);
+            aoc.debugfmt("]\n", .{});
+            if (valid) {
+                aoc.debugfmt("MATCH {s}\n\n", .{line});
+            } else {
+                aoc.debugfmt("NO MATCH {s}\n\n", .{line});
+            }
+        }
+        try nextstack.resize(0);
+    }
+
+    return try std.fmt.allocPrint(allocator, "{}", .{answer});
+}
+
+pub const main = aoc.main(part1, part2, .{ "134", "377" });
diff --git a/src/19/part1 b/src/19/part1
new file mode 100644
index 0000000..22eba35
--- /dev/null
+++ b/src/19/part1
@@ -0,0 +1,79 @@
+--- Day 19: Monster Messages ---
+
+You land in an airport surrounded by dense forest. As you walk to your high-speed train, the Elves
+at the Mythical Information Bureau contact you again. They think their satellite has collected an
+image of a sea monster! Unfortunately, the connection to the satellite is having
+problems, and many of the messages sent back from the satellite have been corrupted.
+
+They sent you a list of the rules valid messages should obey and a list of
+received messages they've collected so far (your puzzle input).
+
+The rules for valid messages (the top part of your puzzle input) are numbered and build
+upon each other. For example:
+
+0: 1 2
+1: "a"
+2: 1 3 | 3 1
+3: "b"
+
+Some rules, like 3: "b", simply match a single character (in this case, b).
+
+The remaining rules list the sub-rules that must be followed; for example, the rule 0: 1 2 means
+that to match rule 0, the text being checked must match rule 1, and the text after the part that
+matched rule 1 must then match rule 2.
+
+Some of the rules have multiple lists of sub-rules separated by a pipe (|). This means that
+at least one list of sub-rules must match. (The ones that match might be different each
+time the rule is encountered.) For example, the rule 2: 1 3 | 3 1 means that to match rule 2, the
+text being checked must match rule 1 followed by rule 3 or it must match rule 3
+followed by rule 1.
+
+Fortunately, there are no loops in the rules, so the list of possible matches will be finite. Since
+rule 1 matches a and rule 3 matches b, rule 2 matches either ab or ba. Therefore, rule 0 matches aab
+or aba.
+
+Here's a more interesting example:
+
+0: 4 1 5
+1: 2 3 | 3 2
+2: 4 4 | 5 5
+3: 4 5 | 5 4
+4: "a"
+5: "b"
+
+Here, because rule 4 matches a and rule 5 matches b, rule 2 matches two letters that are the same
+(aa or bb), and rule 3 matches two letters that are different (ab or ba).
+
+Since rule 1 matches rules 2 and 3 once each in either order, it must match two pairs of letters,
+one pair with matching letters and one pair with different letters. This leaves eight possibilities:
+aaab, aaba, bbab, bbba, abaa, abbb, baaa, or babb.
+
+Rule 0, therefore, matches a (rule 4), then any of the eight options from rule 1, then b (rule 5):
+aaaabb, aaabab, abbabb, abbbab, aabaab, aabbbb, abaaab, or ababbb.
+
+The received messages (the bottom part of your puzzle input) need to be checked against
+the rules so you can determine which are valid and which are corrupted. Including the rules and the
+messages together, this might look like:
+
+0: 4 1 5
+1: 2 3 | 3 2
+2: 4 4 | 5 5
+3: 4 5 | 5 4
+4: "a"
+5: "b"
+
+ababbb
+bababa
+abbbab
+aaabbb
+aaaabbb
+
+Your goal is to determine the number of messages that completely match rule 0. In the
+above example, ababbb and abbbab match, but bababa, aaabbb, and aaaabbb do not, producing the answer
+2. The whole message must match all of rule 0; there can't be extra unmatched
+characters in the message. (For example, aaaabbb might appear to match rule 0 above, but it has an
+extra unmatched b on the end.)
+
+How many messages completely match rule 0?
+
+
diff --git a/src/19/part2 b/src/19/part2
new file mode 100644
index 0000000..6f056a4
--- /dev/null
+++ b/src/19/part2
@@ -0,0 +1,92 @@
+--- Part Two ---
+
+As you look over the list of messages, you realize your matching rules aren't quite right. To fix
+them, completely replace rules 8: 42 and 11: 42 31 with the following:
+
+8: 42 | 42 8
+11: 42 31 | 42 11 31
+
+This small change has a big impact: now, the rules do contain loops, and the list of
+messages they could hypothetically match is infinite. You'll need to determine how these changes
+affect which messages are valid.
+
+Fortunately, many of the rules are unaffected by this change; it might help to start by looking at
+which rules always match the same set of values and how those rules (especially rules
+42 and 31) are used by the new versions of rules 8 and 11.
+
+(Remember, you only need to handle the rules you have; building a solution that could
+handle any hypothetical combination of rules would be significantly more difficult.)
+
+For example:
+
+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
+
+Without updating rules 8 and 11, these rules only match three messages: bbabbbbaabaabba,
+ababaaaaaabaaab, and ababaaaaabbbaba.
+
+However, after updating rules 8 and 11, a total of 12 messages match:
+
+
+ - bbabbbbaabaabba
+ - babbbbaabbbbbabbbbbbaabaaabaaa
+ - aaabbbbbbaaaabaababaabababbabaaabbababababaaa
+ - bbbbbbbaaaabbbbaaabbabaaa
+ - bbbababbbbaaaaaaaabbababaaababaabab
+ - ababaaaaaabaaab
+ - ababaaaaabbbaba
+ - baabbaaaabbaaaababbaababb
+ - abbbbabbbbaaaababbbbbbaaaababb
+ - aaaaabbaabaaaaababaa
+ - aaaabbaabbaaaaaaabbbabbbaaabbaabaaa
+ - aabbbbbaabbbaaaaaabbbbbababaaaaabbaaabba
+
+
+After updating rules 8 and 11, how many messages completely match rule 0?
+
+
diff --git a/src/19/trace b/src/19/trace
new file mode 100644
index 0000000..5373679
--- /dev/null
+++ b/src/19/trace
@@ -0,0 +1,38 @@
+STACK TRACE FOR aaaabbaaaabbaaa
+
+[0]
+-> [8] 11
+    -> [42] | 42 8
+    -> [9] 14 | 10 1
+        -> 14 27 | [1] 26
+        -> 14 27 | (1) [26]
+        -> 14 22 | [1] 20
+        -> 14 22 | (1) [20]
+        -> 14 14 | [1] 15
+        -> 14 14 | (1) [15]
+        -> [1] | 14
+    -> (9) [14] | 10 1
+-> (8) [11]
+    -> 42 31 | [42] 11 31
+        -> 9 14 | [10] 1
+            -> 23 14 | [28] 1
+                -> [16] 1
+                    -> [15] 1 | 14 14
+                        -> 1 | [14]
+                    -> (15) [1] | 14 14
+                -> (16) [1]
+            -> 23 14 | (28) [1]
+        -> 9 14 | (10) [1]
+    -> 42 31 | (42) [11] 31
+        -> 42 31 | [42] 11 31
+            -> 9 14 | [10] 1
+                -> 23 14 | [28] 1
+                    -> [16] 1
+                        -> 15 1 | [14] 14
+                        -> 15 1 | (14) [14]
+                    -> (16) [1]
+                -> 23 14 | (28) [1]
+            -> 9 14 | (10) [1]
+        STOP HERE
+
+