Added day5 and brought more structure into days

in/5.txt

@@ -0,0 +1,945 @@
+FBFFBFFRLL
+BFFBFBBLRR
+FFFBFBFLLR
+BBFFFBBRRR
+FBFFFFBLLR
+BFFFFBFRLL
+FBBFFBBRRL
+BFBBBBFLLR
+BBBFFFBLLL
+BBFFFBBLRL
+FFFBFFFLRL
+FFBFBBBLRL
+FFFBBBBLRL
+BFFBBBFRLR
+FBFFBFBLLR
+BBBFBBFLRL
+BFFBBFBLLR
+FBBFBFFRRL
+FBFFBBFLLL
+BFBFFBBRLL
+FBBFFBFRLR
+BFFFFFBLLL
+FBFBFBFRLL
+BFBBFFBLLR
+BBBBFBBLLL
+BFFFBBFLLL
+FFBBFBFRLL
+FFBFFBBLRR
+BFFBFFFRRL
+FBFBBFBRLR
+BBFBFBBRLR
+FBBBBFFLRL
+BFBBFFBRRR
+BFBFFBFLLL
+FFBBBFFRLR
+FBFBFBBRRR
+BBBFFBBLLR
+BBFBBBBLRR
+BBFFFFBRLL
+BFBBBBFLRR
+BBBFBBFRRR
+BFFFFFBRRL
+BBFBBFBRRL
+BFFFBBFRRR
+BFFBFBFLRL
+FFBFFFBRLL
+FFBBBFFLRL
+FBFFFBFLRL
+FFFBFFFLRR
+FBFBBFBRRR
+BFBFBFFRRR
+BBFBBBBLRL
+FBFFFFBRLR
+FFBBBBFLRL
+BBBFFFFRRL
+BFBFFBFRRR
+FFBBBFFLRR
+FFFBFBBRRL
+BFBBBBBLRL
+BFFFFBFRLR
+BBBFFBFRLL
+FFFBBBBLLL
+FFBFBFFLRR
+BFFBFFFLLL
+BFFBFBFLLL
+BFFBBBFLLR
+FBBFBFBRRR
+FFFFBBBLLR
+FFFBFBBRLR
+FBBFBFFLRR
+FFFBBBFRRR
+FFFBBBFLRL
+BFBFBBBRLR
+BBFFBFBRLR
+FFBFBFFRRL
+BBFFFBFRLL
+BFFFBBBRLR
+FFFBBFFRLL
+FBFFFFBLRL
+BFFBFBBLLL
+BFBBFFFLLL
+BFBFBBFRLR
+BFBFFFFRRR
+FFFFBBFRLL
+BFFFBFFRRR
+FFBFFFFRRR
+BBBFFFFRLL
+FBFBBBBRLL
+BBBFBBFLLR
+FFBFFFFRLL
+BBBFBBBRLR
+BFFBFFFLRR
+FBFBFBBRLL
+FBBFBBFRLR
+FFBBFFBLRL
+BFBFBBBRRL
+FBBBBBBLRL
+FBFFFBBLRR
+BBFBBFBRLR
+FBFBBBFRLL
+FBBFFFBLLR
+BFFFFBFLRR
+FBFFBBFRLR
+BFFFBFFRLR
+FFFBBFFLRR
+FFBBFBBRRL
+FBFBFFFLRL
+FBBBBFBLLR
+FBBFBBBRRR
+FFFFBBFLRR
+FBBFFFBRRL
+FBBFBBBLRL
+BBBFBFBRRL
+FBFBFFFLLL
+FFFBFBFLRL
+BBFFFBBRLR
+BBBFFBFLRR
+BFBBBBFLRL
+FBFBBBFLLR
+FBBFFFFRRL
+BFBBBBBRLR
+BBFFBBBRLR
+BBBBFFFRLL
+BBFFFFBRRR
+FFBFBBFRLL
+BFFFBBFRLL
+FFBBBFBLLL
+BFBFBFFLRL
+BFFFBBFLRR
+BFFFBBBRRL
+BFFFFFFLLL
+FFBFFBFRLR
+BFFBBFFLLL
+BBFBFBBLLR
+FBFBFBBRLR
+FFBFBBBRLL
+FFBFBBBLLR
+BBBFFFBRRR
+BBFFBBBRRL
+BBFFBBBRLL
+FFBBFBBLLL
+FBBBFBBLLR
+BFBFBFBRLR
+FBFFBFBRRL
+FBBBBBFRRR
+BBFFBBFLRL
+BBBBFFBRLL
+FFBFFFFLLL
+BFFFFBFLLL
+FFBFFBBLRL
+FBBBBBFLLR
+BFBFBBBLLR
+BBBFBFFRRR
+BFBFFBBRLR
+BFFFFFBLLR
+BFBFBFBRRL
+FFBFFBBRRL
+FBBFBFBRLR
+BBFFBBFLRR
+FBBFFBFLLL
+FFFFBFBRRL
+BFBBBFFLRL
+FFBBFBFLRR
+BBBFFFFRLR
+FBBBBBFLRR
+BBFFBFBLRL
+BFBBFFFLLR
+BBFFFFBLRR
+BFFFFBBLLR
+FBBFFBBRLR
+FBBBFFBRLR
+BBBBFFFRRL
+BFFBBBFLRL
+FBBBFFBLRR
+BFBFBFBLRR
+FBBFFBFLLR
+BFBFFBFRLR
+FBFBFFFRRR
+BFFFBFFLLL
+FFBBBFFLLR
+BBBFFFFLRR
+FBBFFFBRRR
+FFBFBBBRRL
+FFBBBFBLRR
+BFFFFFBRLR
+FFFBFBBLRL
+BFBFFFBRLR
+FFBFFBBRLR
+BBFBFBBRLL
+BBFFBFBRRR
+BFFFFFBRRR
+FFFBFFBLLL
+FFBBFBFLLR
+BFFBBBBLLL
+BBFFBFBRRL
+FFBBFFFLRR
+BFFFFFFRRL
+FFBFFFBRRR
+FFBBBFBLLR
+FFBFFFFLRR
+BFFFBFBLRL
+BFBBFBBLRL
+BFFFFFFRLL
+BBFBFBFLRL
+BBFBFBFLLR
+FFBFFBFRLL
+FFFFBBBRRL
+BFFFBFFRRL
+BFFBBFBRLL
+FBFFBBBRLR
+FFBBFBFRRR
+BFFBBBBLRR
+BFFBFFBLLL
+BBBBFBFLRL
+FBBFBBFRRR
+FBBFBFBRLL
+BBBFBBFLLL
+BFFBFFBRLR
+FFBBFFBLLL
+BFFBBFFRRR
+BBFBBFFLLL
+BBBBFBFRLR
+FFBBFFFLLR
+BFFBFBFLRR
+FBFFFFBLRR
+FBBBFFFLRR
+BFBBFBFLLR
+BBFFBFFLLR
+FFFBFBFLLL
+FFBFBBBLLL
+FBBFFBBLRR
+BFFFBBBRLL
+BBFBBFFRLR
+FBFBFBFLRR
+BBBFBFFRLL
+FBFBBBFLRR
+BBBBFFBRRL
+BBBBFBFLRR
+FFBFFBFLRR
+BFFBFFBRRL
+FFFBFBFRLR
+FBBBBFBLRL
+FFFBFBBRRR
+FFBFFBFRRL
+BFFFFBBRRL
+BBBFBBBLRL
+FBBFFBBLLR
+BBFFFFBLLR
+FBFFBBFLRL
+FFBBFFBRLR
+BFBBBFBRRL
+BFBFFBFLLR
+BBFBBBFRRR
+FBFFFBFLLR
+FFBBBBBRLR
+BFBBBFBLRR
+BFBFBFBLLL
+FFBFBBFLLR
+FFFFBBFRLR
+BBFFBBFRRR
+FFBBBFFRRL
+FFBBFBFLLL
+FFFBFBBRLL
+BBFBFFBLRR
+FFBBFFBLLR
+BBFFFBBRLL
+FFBFFFBLRL
+BBFBFFFRLR
+BBFBBFFRRR
+FFBBFBFLRL
+FFBFFFFLLR
+FFFFBBFRRL
+BBFFFFFLRR
+FBBFFFBRLR
+BFBFFFFLLL
+BBBBFFFLLL
+BBFBFFFRLL
+FFFBFFFRRL
+BBBBFBBRRR
+FFBBBFFLLL
+BBBFFFBRLL
+FFBFFBBRLL
+BFBBFFFLRL
+BBFBFFBLLR
+BFBFFBFLRR
+BFBFBBFRRR
+FBFFFBBRLL
+BFBBFFBLRR
+BBBFBBBRLL
+BFFBFFFRRR
+BFFFBFBLLR
+FFBFBFBRLL
+FBFBBBBLRR
+FFBFBFBLLL
+FBFFFBFLRR
+FBFBBBFLLL
+FBFFFBFRRL
+BBFBBFBLRL
+FBBBFFFRLR
+FBBBBFFRRL
+FFBFBBBLRR
+FBBFBBBLRR
+BFFFBBBLRR
+BFBFBBBLRR
+FFFBBFFLLL
+BFBBBBBRLL
+BBFBFFBRLL
+BBFBBBBRLL
+BFFBFBFRRL
+BFBFBBFLRL
+FBBBFBBLLL
+FBBBBBFRLL
+FFBBFBBLRR
+BFBBBBFRRR
+BFBFBBFLLR
+BFBBFBFRRR
+FBBBFBBRLL
+FFFBBFFRRR
+FBFBBFBRRL
+BFBBBFBLRL
+FFFBBBBLLR
+FBBFBBFLLL
+BFFFBFFLRR
+FFBFFBFLLL
+BFFFFFFRRR
+BBFBBBFRRL
+FFFFBBFLLL
+BBBBFFFLLR
+FBFFBBBRRL
+BBFBBFBLLL
+BBFBBBBRRR
+BFFFBFBRRR
+BFFBFBFLLR
+FFFBFFBRRR
+BBFFFBFLRL
+FBFFBBBLRR
+FFBBFFBRRR
+BBFBFFBRLR
+BBBFBFFLLR
+FBBBBBBRRL
+BFFBBFFRRL
+FFFBFFBLLR
+FFFBBBFLLR
+BBBFBFBRLR
+FBFFBBFLLR
+BFBBFBFLRL
+BFBFBFBRRR
+BBBFFBBRLL
+BBBFBBBLLL
+FFBBBBBRRR
+BBBFFFFLLL
+FBFBFFBRLL
+BBFFBBFLLL
+BFFFBFBRLL
+BBFFBFFRRR
+FBFBBBFRRL
+BFBBFFFRLL
+BBFFBBBLLL
+BBFFFBBLLR
+FBBBBBFLRL
+FFFFBBBLRR
+FBBFFBFLRR
+FBBBFBFRLL
+BFBBBBBLLL
+BFBFFBBLLR
+BFBBFBBRRR
+BBFFFBFRRR
+FBBFFFBLLL
+BBFBFBFRRL
+BFFFFBBRLR
+BBBFFBBLRL
+BBBBFBBRLL
+FFBFBFBLLR
+FBFFFFFRRL
+FBBBFBBRRR
+BBFBFBBLRL
+BFFBFFBRLL
+BFBBBFFLLR
+FFBFBFFLLL
+BBFFFFBLRL
+BFBFFBBLRR
+FBBFFFFRRR
+BFFBFFBLRR
+FBBFBBBRLL
+BFBBBBFLLL
+FBFFFBFRLL
+BFBBFBBRLL
+BFBBBFBLLR
+BFFBFBBLLR
+FBFBFBBLLL
+FFBFFFFRRL
+FBBBFFBLLR
+BBFBBBBLLR
+BFFFFBFRRR
+FBFFBFBRLL
+BFFBFFFRLL
+FBBBBFFLLL
+BBBFFBBLRR
+FBFBFFBRLR
+BBBFFFFLRL
+BFFBBFBLRL
+FBFBFFFRLR
+FFFFBBBRLL
+FFFFBBBLRL
+FBBFBFBLLL
+BFBBBBBLLR
+FBFFFBBLRL
+BFBFFBFLRL
+BFFFFFFLRL
+BFFBBBFLRR
+BBBFBBBRRR
+FBBBBBBLRR
+BFFBFBFRLR
+BFFBBFFLRR
+FBFFFFFLRR
+FBFFBFBLRL
+FBFBBBBRRL
+FFFBBBBRRL
+BFFFBFFLRL
+BFFBFFBLRL
+BBBBFBFRLL
+FBBBFBFRLR
+BFBFBFFRRL
+BBBFFBBLLL
+FFBBBBBLLR
+FBFBFFBLRL
+BFFBBBBRLR
+BFFBFBFRRR
+FFBFFFFLRL
+BBBFBFFRRL
+FFBBBBBRRL
+BBFBFBFRLR
+FBBBBBBRLL
+BBBBFBBLLR
+FBFBFBFRLR
+FFFBFFFLLL
+BFBFFFBLRR
+FBFFFFBLLL
+BFBFFFFRLR
+FBBBBBFLLL
+BBBBFFBLRL
+BFFBFFFRLR
+FBFBBFFRRR
+BFFBBFFLRL
+FBBFBBBLLL
+FBFFBFFLLR
+BFFBFFBLLR
+FFBBFFFRRR
+BBBFBFBLRR
+BFFBBBBRRR
+FFFBBFFLRL
+FBBBFBBLRR
+BBFBBBFRLR
+BBFFFFFRRL
+FBFBFBFLRL
+BBBBFFFLRR
+FFBFFFBLLL
+FFFFBBBLLL
+FFBBBBBLRR
+FBBBFFBLRL
+FFBFFBFLLR
+FBBBBFFLLR
+BFBFFBBLRL
+FFBFFBBRRR
+BBFFBBFRRL
+FFBBBFBRLR
+BBBFBBFRLR
+FBBFBFBLLR
+FBBBFFFRRL
+FBFBFFBLLR
+BFBBFBBLLL
+FBBFFFFRLR
+BBFBBBFLRR
+FBFFBFBLRR
+FBFBFFBRRR
+FBFFBFBLLL
+BBBFFBFRRL
+BBBFFBBRLR
+BBFFBFFRLL
+FFBFFFBRLR
+BFBBFBFLRR
+FBBBBFBRRL
+FFBFBFFRRR
+BFFFFFFLRR
+FBBBBFFLRR
+FFBBFFBLRR
+BBBFFFFLLR
+FFFBFFFRLR
+FFFBFBFRRL
+BFBBBBFRLL
+BFBFBBFLLL
+FFFBFFBLRL
+BFBBFBFRLL
+FBFBBFFRRL
+BFFFBFBRRL
+FFBBBBFLRR
+FBFFBFFLRR
+FBBBBBBRLR
+FBBBFFFRRR
+FBBBFFBRLL
+BFBBFFBLRL
+BFBBBBBLRR
+BBFBBBBRLR
+BBFFFFBRRL
+FFFBBBFLLL
+BFFFBBBLRL
+FFFFBBFLLR
+BBFFFBFRRL
+BFFFBFBLRR
+BFFFBBBRRR
+FBFBBFBLLL
+BFBBFFFLRR
+FBBBFFFLLL
+BFBFFFFLLR
+FBFBBFFLRR
+BBBFBFBLLL
+BBFBFFBLLL
+BFBFBFBLRL
+BFFBBBFLLL
+BFFFFBBRRR
+FFBBBBFLLR
+FBBBFFBLLL
+BFFBBBFRRR
+FBFBFFFLLR
+FFFBBFBRRL
+BBFBFBBLLL
+BBBFBFBLLR
+FBFFFFBRRR
+FBFFFBBLLL
+BFFFFBBLRR
+BFFBBFBLRR
+BFBFFFBRRR
+FFFBBFFRRL
+FFBBFFFLLL
+FFBBBBBLRL
+FBBBBBFRRL
+FBFFFBFLLL
+BBFBBFBLLR
+BFBBFBBRRL
+BFBBFFBRLL
+BBFBBFFRLL
+BFFBFBBRRL
+FFFBFBBLLR
+FFFBBFBLLR
+FBFFFFFRLR
+FBBBBFFRLR
+FBFFBBFRRL
+FBFFBBBRLL
+BFFBBFBRRL
+BFFFFBBLLL
+FFBBBFBRRR
+BBBFBBBRRL
+BBBFFBFLLL
+FFFBBBBRLL
+BBFBFBFLLL
+BBFBFBBRRL
+FFBBBBBLLL
+FBFFBBFRLL
+BBFFBFFRRL
+BFBBBFBRLR
+FBFFBBBLRL
+FFFBFBFRLL
+BFBFFFBLLL
+FBBBBBBRRR
+FBFBBBBRRR
+FBBBFBBRLR
+BFFFFBBRLL
+BBFBFFFRRL
+BFBBBFFLRR
+FBBBFBFRRL
+FBBFFBFLRL
+BFBBFFFRRR
+BFBBFBFLLL
+FBBBBFBRRR
+FBBFFBFRLL
+FBFFFFFLLR
+BBBFBBFLRR
+BBFFFBFLLR
+BBFFFBFLLL
+FBFBBBFLRL
+FFBFFFBRRL
+BBFBFBFRRR
+FBFFBBFRRR
+BBBFFBBRRR
+BFFFBBFLLR
+FFBBFBBLRL
+FBFBFBFLLR
+FBFBFFFLRR
+FFBBBBFLLL
+FBFBFFBLRR
+BBFFBBFRLR
+FBBBFFFLLR
+FBFBFFFRRL
+BFFBBBBRRL
+FBBFFBBLLL
+BBFBBFBRLL
+FBBBFBBLRL
+BFFFFFFLLR
+FBBFBFFLRL
+FBFFBBBRRR
+FFBBBFFRLL
+BFFBFBBLRL
+FBFBFFBRRL
+FFFFBBBRLR
+BBBFBFFLLL
+FFFBBFBLRR
+BFFBFBFRLL
+FBFBBFFLRL
+BBFFBBFLLR
+FBFBFBBLLR
+BBFFFBFLRR
+BFFFBFBLLL
+FBFBFBFRRR
+FBBFFBFRRR
+FFFBFFFRLL
+FFBBFBBRLR
+FFFBFFBRRL
+BBBFBFBLRL
+FBBFBFFRRR
+BBBFFFBRRL
+FBBFBFFLLR
+FBFFFBBRRR
+BBBFBBFRRL
+BFFBBFFRLL
+FFFBBBBLRR
+BBBBFFFLRL
+FFBBBFBRLL
+FFFBFFFRRR
+BBFFBFFRLR
+BBFFFFFRLR
+FBFBBBBLLR
+FFBFFBBLLR
+FBBBBFFRLL
+BFBBBFFRRR
+FBFBBFBLRL
+FBFBBFFRLL
+FBBFFFFLLL
+FBBFBFBRRL
+FBBBBBFRLR
+BFBBFFBLLL
+FFBFBFBLRL
+FBFFBFFRLR
+FFBBBBBRLL
+BBFBFFBRRL
+BBBBFBBLRL
+BFBFBBFRLL
+FBBFBFFRLL
+FBBBBFBLLL
+FFBFBFFRLL
+FBFFBFFRRR
+FBFFFFFRRR
+FBBBFFFLRL
+BFBFFFBLRL
+FBFFFFBRRL
+FFBBFFFLRL
+BFFFFFBLRL
+FBFFBFFLLL
+FBFBBBBRLR
+BFFBBBFRLL
+BBFBFFFLLR
+BBFBFBBLRR
+FBFFFBBLLR
+FFBBFBFRLR
+FBBFFBFRRL
+FFFFBBFLRL
+FBBFFFBLRR
+BFBBBFFRLR
+BFBFFFBRLL
+FFBBFBBRLL
+BFBFFBFRRL
+FFBFBBFLRL
+BFFBBFFLLR
+FBFBFBFRRL
+FFFBFFFLLR
+BBFBBFFLRR
+BBFFBBBLRR
+BBBBFBFLLR
+FBFBBFFLLL
+FBBBFBFLRL
+BBFBBFBLRR
+BFFBBBBRLL
+BBFBBBFLLL
+FBFFFBBRLR
+FFFBBBFRLL
+BFFFFFBLRR
+FBFBBBFRLR
+FBBFFFFLRR
+FFBBFBBLLR
+FFFBBFBRLL
+FBBFBFFRLR
+FBFFBBFLRR
+BBBFFFFRRR
+FFFFBFBRRR
+BBBFFFBLLR
+FFBFBFBRRL
+BFBBBBFRLR
+BBBFFBFRLR
+FFFBBBBRLR
+FBBFBBFLLR
+FFBBBBFRRL
+BFFBFBBRRR
+FBFFBBBLLR
+BFFBBFBLLL
+BFBFBBFRRL
+FFFBBFBRRR
+FFBBBBFRRR
+BFBBBFFRLL
+BFFBFBBRLL
+FFBBBBFRLR
+BBFBBBBLLL
+BFBFBFBRLL
+BFBBFFBRLR
+BBBFFBBRRL
+BBFFFFBLLL
+FBBFFFBRLL
+FFFBBBBRRR
+BFFFBBFRLR
+BBFBFBFLRR
+FFBFFBBLLL
+FFBBFFFRLL
+FBBBFBBRRL
+FBBBFBFRRR
+FFBBBFFRRR
+FBBFBBBRLR
+FBBFFFFLLR
+FFBFBBFRLR
+BFFFFBFLRL
+BBFFFFBRLR
+BFBBBFBRLL
+BBFFFFFRRR
+BFBFBBBLRL
+BBFBBBBRRL
+BBBFFBFLLR
+BFFBBBBLRL
+FBFBFBBRRL
+BFFFBFFLLR
+BBBFBFBRRR
+BFFFBBFLRL
+FBBFBFFLLL
+FFFBFFBRLL
+FFBFFBFLRL
+FBBFBFBLRR
+FBBBFFBRRL
+BFBBFFFRLR
+BFFBFFBRRR
+BFBBBBFRRL
+BBBFBBFRLL
+BBFFBFFLLL
+BBBFBFFLRL
+FFBBBBFRLL
+FBFFFBFRRR
+BFBFBBBRLL
+FBFBBFFRLR
+FBFBBBBLRL
+FBBFFBBRLL
+FBFBFFFRLL
+BBFFBBBLRL
+FBFBBFBLRR
+FFFBFBFLRR
+FBFBFFBLLL
+BBFBFBBRRR
+BBFBBBFRLL
+FBFBBBFRRR
+BBFFFFFRLL
+FFBFFFFRLR
+BFFFFFFRLR
+BBBBFBFLLL
+FBFFBBBLLL
+BFFFBBBLLR
+FBBBBFBLRR
+BBFFFBBLRR
+BFBBFBBRLR
+FBFFFFFRLL
+FBBBBFFRRR
+BBFFFBBLLL
+BFFBBFBRRR
+BBFBBBFLLR
+FBBFBBBRRL
+FBFBBFFLLR
+BBBFFFBRLR
+FFFBFFBRLR
+FBBBBBBLLL
+BBFFBFBLLL
+FBBFBBFRLL
+BBBFFFBLRL
+BFBBFBBLRR
+BBFFBBBRRR
+FBFFBFFLRL
+FBBFFBBRRR
+BBBFFFBLRR
+FFFBBFBRLR
+BBBBFFBLLR
+FFBBBFBLRL
+FFBFBBFRRL
+FFBFBBFLRR
+FBBBFFBRRR
+FBBFFFFRLL
+BBFFFFFLLL
+FFBFBFBRRR
+BFBBFBFRRL
+BBFBFBFRLL
+FFBFFBFRRR
+FBBFBBFLRR
+FBFFBFBRRR
+BBFFFFFLRL
+FBBBFFFRLL
+BBFBBFFRRL
+FFBBBFBRRL
+FFBFFFBLLR
+FBFBBFBRLL
+FFBFFFBLRR
+BFFBBBFRRL
+BBBBFBBRLR
+BFBBFFBRRL
+BBFFFFFLLR
+BBFFBFBLRR
+BBBBFFBRRR
+BFBBBFFRRL
+FFFFBBBRRR
+BFFFFFBRLL
+BBFFBFBLLR
+BBBFBFBRLL
+BBBBFBBRRL
+FBBFBBFRRL
+BBFFBFFLRL
+FFFBBFFRLR
+FBBFBFBLRL
+BBBBFFBLLL
+FFBFBBBRRR
+BFBFBFFRLL
+BFBBBFBRRR
+BBFBFFBLRL
+FFFBBBFRRL
+BBBFBFFRLR
+BBFFBFFLRR
+FFBFBBBRLR
+BFBFFBFRLL
+FBBBFBFLLR
+BBFBBFFLLR
+BFBFBBBRRR
+FBFFBFFRRL
+FBBBBBBLLR
+BBFBFFBRRR
+BBBFBBBLRR
+BFBFFFFLRL
+BFBFFFFRRL
+BBFBFFFLLL
+BFBFBFFLLR
+FFFBBFFLLR
+FFFBBFBLLL
+BFBBFBBLLR
+BFBFBFBLLR
+BBFFBBBLLR
+BFBFFBBLLL
+FBBBFBFLRR
+FBFFFFFLLL
+BFFFBBFRRL
+BFBFFFFRLL
+BBFFBFBRLL
+BFBFBFFRLR
+FBFFFBBRRL
+FBBBBFBRLR
+FFBBFFBRLL
+BFBBFBFRLR
+FFFBFBBLRR
+BFBFFFFLRR
+BFFFBFFRLL
+FFFBBBFLRR
+FFBBFFFRLR
+BFBBBFBLLL
+FFBBFBBRRR
+BFBBFFFRRL
+FFFBFBFRRR
+FBBBBFBRLL
+FBFFFBFRLR
+BFFBBFBRLR
+BBBFFBFRRR
+FFBFBFFLRL
+FBFBBBBLLL
+FBBFFFBLRL
+BBBFBFFLRR
+FBFFFFBRLL
+FFBBFBFRRL
+BFBFBBBLLL
+FBFFBFBRLR
+FBFBBFBLLR
+FFBFBFFLLR
+BFBFBFFLLL
+BBFBFFFLRR
+FBBFFBBLRL
+BBBBFFFRRR
+FFBFBFBRLR
+BFBBBBBRRR
+FBBFFFFLRL
+BFFFBBBLLL
+FFBFBFFRLR
+BBBBFBFRRL
+FBBBFBFLLL
+BFBFFFBRRL
+BBBFFBFLRL
+BBBBFFBLRR
+BBBBFBFRRR
+BBFBBBFLRL
+FFFBBFBLRL
+FBFBFBBLRR
+BFBFFBBRRL
+BBBBFBBLRR
+BFFFFBBLRL
+FBFBFBFLLL
+BBBFBBBLLR
+BFBFFFBLLR
+FFBFBBFRRR
+FBBFBBBLLR
+BFBBBBBRRL
+BFFBBFFRLR
+FFBBFFBRRL
+BBBBFFBRLR
+BBFFFBBRRL
+BBFBBFFLRL
+FFBBFFFRRL
+BBFBFFFLRL
+BFBBBFFLLL
+BFFFBFBRLR
+FFBFBBFLLL
+BBFFBBFRLL
+BBFBFFFRRR
+BFFBFBBRLR
+FFBFBFBLRR
+BFFBFFFLLR
+FFFBBBFRLR
+BFBFFBBRRR
+BFFFFBFLLR
+FBFFFFFLRL
+BFFBBBBLLR
+BBBBFFFRLR
+FBFBFBBLRL
+FFFFBBFRRR
+FFFBFBBLLL
+BFFBFFFLRL
+BFBFBBFLRR
+BBFFFBFRLR
+BFBFBFFLRR
+FFFBFFBLRR
+BBFBBFBRRR
+FBBFBBFLRL

source/app.d

@@ -4,20 +4,23 @@ import std.conv;
 import std.format;
 import std.stdio;
 import std.getopt;
+import std.variant;
 
 import day1;
 import day2;
 import day3;
 import day4;
+import day5;
 import dayutil;
 
 immutable string progName = "aoc-2020";
 
-void function(string[])[] programs = [
+Variant function(int, File, string[])[] programs = [
 	&day1.run,
 	&day2.run,
 	&day3.run,
 	&day4.run,
+	&day5.run,
 ];
 
 void printUsage(string name) {
@@ -34,7 +37,7 @@ void printUsage(string name, string message) {
 
 void main(string[] args) {
 	int day;
-	if (args.length < 2) {
+	if (args.length < 3) {
 		printUsage(args[0]);
 	}
 	try {
@@ -47,9 +50,16 @@ void main(string[] args) {
 		printUsage(args[0], "[day] must be between 1 and %d".format(programs.length - 1));
 	}
 
+	int part;
+	try {
+		part = to!int(args[2]);
+	} catch (ConvException e) {
+		printUsage(args[0], "[part] is not an integer");
+	}
 	
 	try {
-		programs[day - 1](args[2..$]);
+		Variant result = programs[day - 1](part, stdin, args[3..$]);
+		writeln(result);
 	} catch(ArgumentException e) {
 		printUsage(args[0], e.msg);
 	} 

source/day1.d

@@ -6,22 +6,23 @@ import std.format;
 import std.functional;
 import std.range;
 import std.stdio;
+import std.variant;
 
 import dayutil;
 
 immutable string progName = "aoc-2020";
 
-void run(string[] args) {
+Variant run(int part, File input, string[] args) {
 
 	/* For each line on stdin, copy it, map it to an integer and sort it.
 	   Sorting a range makes it a SortedRange and functions like contains(range, elem)
 	   will make use of optimised implementations, in the case of contains(range, elem)
 	   it will use a binary search instead of a linear search */
-	auto numbers = stdin.byLineCopy.map!(a => to!int(a)).array.sort;
+	auto numbers = input.byLineCopy.map!(a => to!int(a)).array.sort;
 
-	int solution = parts!int(args, partial!(part1, numbers), partial!(part2, numbers));
+	Variant solution = parts!int(part, partial!(part1, numbers), partial!(part2, numbers));
 	enforce(solution >= 0, "No solutions found");
-	writeln(solution);
+	return solution;
 }
 
 int part1(SortedRange!(int[]) numbers) {

source/day2.d

@@ -2,15 +2,16 @@ import std.algorithm;
 import std.format;
 import std.functional;
 import std.stdio;
-
+import std.variant;
 
 import dayutil;
 
-void run(string[] args) {
-	ulong count = parts!ulong(args,
-			() => stdin.byLine.count!(l => isPasswordValid1(l)),
-			() => stdin.byLine.count!(l => isPasswordValid2(l)));
-	writeln(count);
+Variant run(int day, File input, string[] args) {
+	auto lines = input.byLine;
+	Variant count = parts!ulong(day,
+			() => lines.count!(l => isPasswordValid1(l)),
+			() => lines.count!(l => isPasswordValid2(l)));
+	return count;
 }
 
 /// Part 1

source/day3.d

@@ -5,18 +5,18 @@ import std.range;
 import std.stdio;
 import std.traits;
 import std.uni;
+import std.variant;
 
 import dayutil;
 
-void run(string[] args) {
-	auto input = stdin.byLineCopy.array;
-	ulong count = parts!ulong(args,
-			() => input.countTrees1,
+Variant run(int part, File input, string[] args) {
+	auto inputData = stdin.byLineCopy.array;
+	Variant count = parts!size_t(part,
+			() => inputData.countTrees1,
 			() => [[1,1], [3,1], [5,1], [7,1], [1,2]]
-				.map!(x => input.save.enumerate.countTrees2(x[0], x[1]))
+				.map!(x => inputData.save.enumerate.countTrees2(x[0], x[1]))
 				.fold!((x, y) => x * y));
-
-	writeln(count);
+	return count;
 }
 
 ulong countTrees1(Range)(Range lines) if (isInputRange!Range && isSomeString!(ElementType!Range)) {

source/day4.d

@@ -4,6 +4,7 @@ import std.functional;
 import std.range;
 import std.stdio;
 import std.traits;
+import std.variant;
 
 import dayutil;
 
@@ -46,12 +47,12 @@ struct Passport {
 			&& eyeColour.length > 0 && passwordId.length > 0;
 	}
 }
-void run(string[] args) {
-	auto lines = stdin.byLineCopy.array;
-	size_t result = parts!size_t(args, 
+Variant run(int part, File input, string[] args) {
+	auto lines = input.byLineCopy.array;
+	Variant result = parts!size_t(part, 
 			() => part1(lines),
 			() => part2(lines));
-	writeln(result);
+	return result;
 }
 
 size_t part1(Range)(Range range) if (isInputRange!Range) {

source/day5.d

@@ -0,0 +1,42 @@
+import std.algorithm;
+import std.array;
+import std.conv;
+import std.range;
+import std.stdio;
+import std.string;
+import std.variant;
+
+import dayutil;
+
+Variant run(int part, File file, string[] args) {
+	auto lines = file.byLine;
+	Variant result = parts!int(part, 
+			() => part1(lines));
+	return result;
+}
+
+int part1(Range)(Range range) if (isInputRange!Range) {
+	return range.map!(x => determineSeat(to!string(x.array))).maxElement;
+}
+
+int determineSeat(string code) {
+	int result = 0;
+	int marker = 0b1000000000;
+	foreach(char c; code[0..7]) {
+		if (c == 'B') result |= marker;
+		marker >>= 1;
+	}
+	//writeln("ROW: ", result >> 3);
+	foreach(char c; code[7..10]) {
+		if (c == 'R') result |= marker;
+		marker >>= 1;
+	}
+	//writeln("COL: ", result & 0x7);
+	return result;
+}
+
+unittest {
+	assert(determineSeat("BFFFBBFRRR") == 567);
+	assert(determineSeat("FFFBBBFRRR") == 119);
+	assert(determineSeat("BBFFBBFRLL") == 820);
+}

source/dayutil.d

@@ -13,17 +13,12 @@ class ArgumentException : Exception{
    goes out bounds.
  *
  * Params:
- *     args = Reference to string with arguments, usually from main.
+ *     part = The part to run.
  *     dgs = list of delegates. Which one will be called depends on args[0]
  */
-R parts(R)(ref string[] args, R delegate()[] dgs ...) {
+R parts(R)(int part, R delegate()[] dgs ...) {
 	ulong len = dgs.length;
-	enforce!ArgumentException(args.length >= 1, "Please provide a part to run as a command line argument");
-	int part = to!int(args[0]);
 	enforce!ArgumentException(part > 0 &&  part <= len, "This day supports parts %d to %d".format(1, len));
-
-	// Remove the first argument
-	args = args[1..$];
 	
 	return dgs[part - 1]();
 }