From 0cbf16ad5ef593edce83f1970a4cb4e906277577 Mon Sep 17 00:00:00 2001 From: Adam Millerchip Date: Sat, 5 Dec 2020 22:29:55 +0900 Subject: [PATCH] Day 5 Parts 1 and 2 --- README.md | 2 +- day5/README | 44 +++ day5/day5part1.exs | 34 ++ day5/day5part2.exs | 42 +++ day5/input | 851 +++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 972 insertions(+), 1 deletion(-) create mode 100644 day5/README create mode 100644 day5/day5part1.exs create mode 100644 day5/day5part2.exs create mode 100644 day5/input diff --git a/README.md b/README.md index 818b392..2580599 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ My (attempted) solutions to [Advent of Code 2020](https://adventofcode.com/2020) in Elixir. -image +image ## Strategy diff --git a/day5/README b/day5/README new file mode 100644 index 0000000..f48fdd8 --- /dev/null +++ b/day5/README @@ -0,0 +1,44 @@ +Day 5 Notes + ++--------+ +| Part 1 | ++--------+ + +$ elixir day5part1.exs +906 + +Thoughts: +Could do something clever with binaries or the Bitwise module? +The number of rows is even (128), but we're zero-indexed (0-127), so how to deal with calculating half? +- in binary, can just shift one bit. But again, we need to halve a range (e.g. 32 to 63) so not sure + how to do that. + +Instead of storing the range, I decided to store the current "front" seat, and how many rows back to count. +Then we can work with 128 which divides by two without worrying about rounding problems. + +When there are only two seats left, just return the correct one based on the flag. + ++--------+ +| Part 2 | ++--------+ + +$ elixir day5part2.exs +519 + +Thoughts: + +Not really sure what the missing front/back seats was about. Decided just to just compare the sorted list +with itself shifted by one (by zipping them), and finding the first ID without a next ID, and assume +the next ID is my seat. +That turned out to be the right answer. + + ++------------------+ +| Overall Thoughts | ++------------------+ + +Looking forward to seeing how others implemented the seat ID parsing. +Did a lot of refactoring here but the end result, especially for part 2, is pretty clean I think. +Even if I decided to refactor the parser, it can just be swapped in for part 2. Zipping was a nice idea. + +I quite enjoyed this one, maybe because it's a Saturday and I wasn't burnt out from work :-) diff --git a/day5/day5part1.exs b/day5/day5part1.exs new file mode 100644 index 0000000..1a6cdeb --- /dev/null +++ b/day5/day5part1.exs @@ -0,0 +1,34 @@ +defmodule Day5Part1 do + use Bitwise + + def run do + File.stream!("input") + |> Stream.map(&seat_id/1) + |> Enum.max() + |> IO.puts() + end + + def seat_id(boarding_pass) do + {row_spec, col_spec} = boarding_pass |> String.trim() |> String.to_charlist() |> Enum.split(7) + + row = + Enum.reduce(row_spec, {0, 128}, fn + ?F, {front, 2} -> front + ?B, {front, 2} -> front + 1 + ?F, {front, count} -> {front, div(count, 2)} + ?B, {front, count} -> {front + div(count, 2), div(count, 2)} + end) + + col = + Enum.reduce(col_spec, {0, 8}, fn + ?L, {left, 2} -> left + ?R, {left, 2} -> left + 1 + ?L, {left, count} -> {left, div(count, 2)} + ?R, {left, count} -> {left + div(count, 2), div(count, 2)} + end) + + row * 8 + col + end +end + +Day5Part1.run() diff --git a/day5/day5part2.exs b/day5/day5part2.exs new file mode 100644 index 0000000..fc28410 --- /dev/null +++ b/day5/day5part2.exs @@ -0,0 +1,42 @@ +defmodule Day5Part2 do + use Bitwise + + def run do + File.stream!("input") + |> Stream.map(&seat_id/1) + |> Enum.sort() + |> find_seat() + |> IO.puts() + end + + def find_seat([_ | next_seats] = seats) do + Stream.zip(seats, next_seats) + |> Enum.find(fn {seat, next} -> next - seat > 1 end) + |> elem(0) + |> Kernel.+(1) + end + + def seat_id(boarding_pass) do + {row_spec, col_spec} = boarding_pass |> String.trim() |> String.to_charlist() |> Enum.split(7) + + row = + Enum.reduce(row_spec, {0, 128}, fn + ?F, {front, 2} -> front + ?B, {front, 2} -> front + 1 + ?F, {front, count} -> {front, div(count, 2)} + ?B, {front, count} -> {front + div(count, 2), div(count, 2)} + end) + + col = + Enum.reduce(col_spec, {0, 8}, fn + ?L, {left, 2} -> left + ?R, {left, 2} -> left + 1 + ?L, {left, count} -> {left, div(count, 2)} + ?R, {left, count} -> {left + div(count, 2), div(count, 2)} + end) + + row * 8 + col + end +end + +Day5Part2.run() diff --git a/day5/input b/day5/input new file mode 100644 index 0000000..47541e9 --- /dev/null +++ b/day5/input @@ -0,0 +1,851 @@ +FFFBBFBLLR +BFBBBFFRLR +BFBBBBFLRR +BBFBFFFLLR +BBFBFBFLLL +BFBFBFBLLR +FBBFFBFRLR +BFFBBBFLLR +FBFBFFBRLR +FBFFBFFRRR +BBFFFFFLRL +FFBFBBFLLL +BFBBBFBRLL +BFFBBFFRRR +BBFBBFBLLR +BBFBBBBRLL +FFBFFBBRRL +FBFBBFFLLR +BFFFBFBRLL +BFBFBBBRRR +FBBFBFBRLR +BFFBBBFLLL +BFBFBFFRLR +BFFFFBFRLR +BBFFFBFLLL +BBFBFBBLRR +FFBBFBFRRL +FBBFBFFRRR +BFBBBBFRRL +FBBBFFFRRL +FBFFFBBRRL +BBFBBBBLLL +BBFBFFFLLL +BFBFBFBLLL +BBFFBFBLLR +FBFFFBBLRL +BFBBFFBRRL +FFBFFFBRRL +BFFFFFFLRR +BBFBFBBRLL +BBFFBBFRRL +FFBFFFBRRR +BFFFBBFLRR +FBBBBBBRRL +BFBFFBFLRL +FFFFBBBRRR +BFFBFBBRLR +FFFFBBBLLL +FFBFBBFRLL +FBBFFFFRRR +FFFBFBFLLR +FFFBBFFLLR +FBFFFFBRRR +FBBFFBFRRL +FFBBFBBLLR +BFFBBBBRLR +FBFBBFBRLL +FFFBBFBLRL +FBFBBFFLLL +FBFFFFFRRR +FBFBBFBLLL +FBBFFBFRLL +FBFFBBFLLL +BFFFBFBLRL +BFFBFFBRLR +FBBFFFFRLL +BBFBBFFLLL +BFBFFFFLRR +FBBBBBBRRR +FBBFFFBRRR +FFFFBBBRRL +BBBFFFFRLL +FBFBBBFLRL +FBBBBFBRLL +FFBBBFFLRR +FBFFBBBLLL +BFBBFFFRRL +BFFFBBFRRL +BFFBFBBRLL +BFBFBBFLLL +FFFBBBBLRL +FBFBFBFRLL +BBFFBBFRLR +FBBBBBBLLR +BFFFBBBRRR +FFFBBBBLLR +FBBFBFBLRR +FFBBFFBLRR +BFFBFFFRLR +FFBBFBBLRL +FBBFBFFLLL +BFFFFBBLRL +FFBBFBBLLL +FBBBBBBLLL +FBFFFFBLLL +BFBBFBBRRR +FBFBFFFLRR +FFFBFFFRLR +FBFFFBFLRL +BFFBBFFLLR +FBBBBFFLLL +BBFBFBFRRR +BFFFBBBRLL +BFBFBFBLRR +FBFFFFFLLR +BFFFFBFLLR +BBFBFFBRRR +FBFBFFBLLL +FFFFBBBLLR +BFBFBBBLLR +FBBFBBFRRR +FBBFBBBRLR +BFFBFBFLLL +BFFBFFFLRR +FBBBFFFLLL +BFBBBFBRRR +FBBFBFFLLR +BFBBFBFRRR +FBFBBFBLRL +FBFBFFBRRR +BFBBFBBRLR +BFFFFFBLLL +FFBBFFBRLL +FFBBFFFLLR +BBFBFBFLRR +BBFFBBBRLR +BBFBBBFRRR +BBFBBFBLRR +FBBBFBFRRL +BFBBFBFLLR +BFBBFBBLLR +FFFBFFFLLL +FFBFFBFRRR +BFFBBFBRRR +FFFBFBBLLR +BBFFFBFRRL +FBFBBBFRLR +BFBFBBFRLL +BFFFBBFRLL +BBFBBFFLRR +BFFFBBBLLR +FBBFBBFRLR +FBFFBFBLLR +BBFFFBFLRR +BFBFBFBLRL +BFBFBFBRRR +FBBFFBBLRL +FFBBFBFLLL +BFBFFBFRLR +BBFBBBFRRL +BFBFFFFRRL +FFFBFFFRLL +BBFBFFBRRL +BBBFFFBLLR +BBFBFFFLRL +FFBFBBBLRR +FBFFFFFLLL +FFBBFFBLLL +FBBBBBFRLR +FBBFBFFRLR +BBBFFFFRLR +BFBBBBFRLR +FFBFFFFLRL +BFFFFFBRLL +FFBFFFBLLR +FFFBFBFLRL +FBBBBFBLRR +FBFFFBFLRR +BBFBBFFRLR +BFFFFFBRRR +BFFBBFBLLL +FBBBBFBLLL +BBFBBBBLRL +FBFBFBFRRL +BBFBBBBRRL +FFBFFFFRLL +FFBBBBBRLR +FFFBBBFRLL +FBFBBBBRLR +FFBFFBFRLR +FBFFBFFLLR +FFFBBFFRLL +BBFBFBBLLR +FBBFFFFLRR +FBFFBBBRLL +BFBFFBFLLL +BFBFFBFRRR +FFBBBBBRLL +FFBFBBBRRR +BFFBFFFRRR +FBBBBFFRLR +BBFFFFBRRR +BBFBBBBLRR +BFFFBBBLLL +BFFFFFFLRL +BFFBBBFRLR +FFBBFBBRLL +FBFFFBFLLL +FFFBFFBRLL +BFFFBFFLRL +FFBBFBFRLL +FBBBBBFRRR +BFFFFBFRLL +FBBBBFFRLL +BFBBBBBRLL +FBBBFBFLLL +FFFBBBBLRR +FFBFFBFLRL +FBFFBFBRLR +BFBFBFFLLR +FFBFFBBLRR +FFFBFBFLLL +BFBBBFFRRL +FFFBBFFRRR +BBFFBBFLLL +BBFFBBBLLR +FBFBFBBLLR +BFBFBBFLLR +FBBFBFBLLL +FFFBBBBRRR +FBFBFBFLRL +FFFBFFBRRR +FFFFBBBRLL +BBFBBBFLRL +FBBFFFFLLR +FBFFFFFLRR +FBBBFBBRLR +BFFFBFFRLL +FBBBFFBRRR +FBBBFFBLRR +BFFBBBBLLL +FBBFBBBLLR +FBBBBBFRRL +FBFBFBBRRL +FBFBFBFLLL +BBFBBFFRRR +FFFBFBBRRR +FFBBBBBLLL +BFBBBFFLRR +FFFBBBFRLR +FFFBFFBLRL +FBBFFBBLLR +FBFBBBBLLR +BFFFFFFRLL +FFBFFFFRLR +BBFFBBFLRL +BFBBBFBRLR +BFFBFBFRLR +FBBFFFBLLL +FBBBFFBRLR +FFBBFFFRRL +FBFBBFBRRR +BFFBBFBRRL +FBBBFBFRRR +FBBFBFFRRL +FBFFBBBLRL +BFBFFFBRRL +FBBBBBBLRL +BBFBFFBLRL +BBFFFFFRLL +FBFBBBBRLL +BBFBBFBRRL +BBFFFFFLLL +BFBBFFBRLR +BBFBFFBLLL +FBBFBBFLLL +BFFFBFBLLL +BBFBFFFRRR +FBBBBBFLRR +BFFFFFBRLR +FFBBFFFLLL +FFBBFBBRRL +FFFBFFFLRL +FBFFBFBLRL +BBFFBFFLRL +BFFBBFFRLL +BBFBBBFLLR +FBBBFFBRLL +BFBBFBBLRR +BBFFFBFRRR +FFBFFBBLRL +FFFBBBFLLL +FFBBBBFRLR +BFBBFBFLRL +BFFBFBFRRR +FBBFFFFRRL +BBFBBFBLLL +FFBBBFBRRL +BFFFBFFLLR +FBBFFFBRLL +BFBBFBFLLL +FBBFBFFLRR +BFBFFFFLLL +FFBBBFBRRR +FFBBBFBLRR +FFBBBFFRLR +FFBBBFBLLL +FFFBFBBRLR +BFBFFFFLLR +BBFFBBBRLL +BBFBFBFLLR +FFBBBFFRLL +FBFFBFBRLL +FFFBFFFLLR +BBFBBBBLLR +FBFBBBFRRR +BBFBBFBRLL +FFBBBBFRLL +BFBFBFBRLL +FBFFFFBLLR +BFFFFBFLLL +BFBBBBBRLR +BFFFBFBRLR +BFFBFBBLLL +FBFFFBFRLR +FFFBFFFRRL +BBBFFFFRRL +FFFBBBBRLL +FBBFFFFLLL +FFFBFBBLLL +BFFFBBFLRL +FBBBBBFRLL +FBFFBBFRLL +BFFBFFBRRL +BBFFFBBLRL +BBFBBFBRLR +BFBFBFFRLL +BBFFBFFLRR +FFBBBBBRRR +FFBFBBFLLR +FFFBBBFLRR +FBBFFFBRRL +BBFBBBFRLR +FFFBBBBRLR +BFBBFBFLRR +BBFFBBBRRR +FBFFFFBLRL +FBBFFBFLLR +FBBFBBFLRR +BBFFBFFLLR +FFBFFFFLRR +BFBFFFBRLL +FBFBFFFRRL +FBBFFFBRLR +BFFBFFFRRL +FBFFFBBRLR +FBFFBBFRRL +FFBFFBBLLL +BFBFFBBRRL +BFBFBBBRLL +FBFFFBBLRR +FBBFBBBRLL +FBBBBFBRRR +FBBBFFBLLR +BBFBFBBRRR +FFFBBBFLLR +BFFFBBBLRR +FFFBFFBLLR +FFBFFFBRLL +BFBBBBBLLL +FBFFFBBRRR +FFBBFFBLLR +BFFBBFFLRL +FFBBBBBLRL +FFBFBBBRLL +FBBFBBBLRR +FFFBFFBLLL +FFBFBBBLLR +BBFFBBFLLR +FFFBFBBRLL +FFBFBBFRLR +BFFBBBFRRR +BFBFFBFRLL +FFBBFBBRRR +FFBFBFBLRR +BFBBBFBLLL +FFBFBFBRLL +BFFBFFFLRL +BBFBFBFRLL +BFFFBFFLLL +FBFBFBFRLR +FFBFBFFLLR +FBBFBBFLLR +FBBBBFBLLR +FBFFBFFLLL +FFBBBFFRRR +FBBFFFFLRL +FBFFBBFLLR +FFBBBBFLRL +FBBFBFFLRL +BFBFFFBLRL +BFFFFFBLRR +FFBBBBFLLL +BFBBBFFLLR +FBBFBBBLLL +BBFFBBBLRL +FBFBFFFRLR +BFFBFBFRLL +BFBBFBBLRL +BBFFBFFRRR +FBBBFBBLLR +BFBBFFBLRL +FFBFBFFLLL +BFBFBBBRLR +FBBFBFBLLR +FFBBBFFLLR +FFBBBFBRLR +BFFFBBBLRL +FBBFBFFRLL +FBFBFBBLLL +BFFBFBFLRR +FFBFBFFRLL +BBFFBFFRLR +BFBFBBBLLL +BBFFBBBLRR +FBFBBBBLRR +FBBFFBFRRR +BBFBFFFLRR +BFFFFBBRRL +FFBBBFFLLL +BFBBBBFLLL +BBFFFBBRLL +BFFBFFFLLL +FFBBBBFLLR +BBFFFFFRRR +BBFFFFFLRR +BBFBFBBLLL +BBFBFBFRRL +FBBBFFFRLR +FFBBBFBRLL +FBFFBFFLRL +BFBFFFFRLL +FBFFBBBRRR +FBBBFBFLRL +BFBBFFFLRL +BBFBFBFLRL +FFBFFBFRLL +FFBFBBBLRL +FFFBBFFLRR +FBBFBBBLRL +BFBBFFFLLL +FBBFFBFLRL +BFFBFBFLLR +BBFFFFBRRL +BFFFFBFLRR +FFFBBFBRLR +FFBBFBBRLR +FFBFBFBLRL +BFFFFFBRRL +FBBFFBFLLL +FBFFBFFLRR +FFBBBBFRRL +FBFFBBFLRR +FBBBFBFRLR +BFBBFFFLRR +FBFFFBBLLL +FBFBBBFRLL +FBFFBFFRLR +FFBBBFFLRL +FFBFFFBLLL +FBBBFBBRRL +BFFBFBFLRL +FFBFFFFLLR +FBBBFFFLRL +BFFFFBFLRL +BBFBBFBRRR +FFFBBBBRRL +BBFBFFFRLR +BFBFBBBLRR +FFFBBFBLLL +BFBBBBFLRL +FBBFFBBLRR +FFBBFFBRLR +BFBBBBFRRR +BFFBBFBLRR +FBFBFFBRLL +BBFBBBBRLR +BBFFFBFLLR +BFFFFBBLLL +FBBFFFBLRR +FFFBFBFLRR +FBFFBBFRRR +FBBBFFFLLR +BFFFFBFRRR +FBBBFBBRRR +FBFFFFFRRL +BFBFFBBLLR +BFBFFFFRRR +BFBFBBFRRR +BFBBBFBLRR +BFFBFBBRRR +BBFFFBBLRR +BFFBBBBLLR +FBFFFFFLRL +BBFBBBFLRR +BFBBBBBRRR +BFBBFBFRLR +FFBFFFBRLR +BBFBBFFLRL +FBFFFFBLRR +FFFBFBFRRR +BFFBFBFRRL +FFBBBBBLRR +FBFFFFFRLL +BFFBFBBLLR +BBFBFFBRLL +FBBBFBBLRR +FBFBBFFLRL +BFFFFFFRLR +BFFBBBFLRL +BFFBFFBLRR +BFFFFBFRRL +BFFBBBFRRL +BFFFFFBLRL +FFBBBBBRRL +FFFFBBBRLR +BFFBBFFRRL +FBBBFFFRLL +FBBFFBBRLR +FBBBBFFRRL +FBBBFBBRLL +FFBBFFBRRL +BBFFFFBRLL +FBBFFFFRLR +BFBFFFBRLR +FBFFBBFRLR +FBBFFFBLLR +BFBBFFBRLL +FBFFFFFRLR +FFFBBFBRRR +BBFBFBBLRL +BBFFFBFRLR +BFBFBBFRLR +BBFFBFBRLR +FBFBBBBLLL +FBBBFFBLLL +FBFBFFFRLL +BFFBBFFLLL +FBBBBBFLLR +BFFFBBBRRL +FBFFFBFRLL +FBFBFBFLLR +FBFFFFBRLR +BFBBBBBLRR +FFBFFFFLLL +BFBFBFFRRL +FFBFFBBRRR +BBFFFBFRLL +FFBFBFBRRR +FFBFFBFLRR +FBBFFBBRLL +BBFFBBFRLL +FFBFBBFLRL +FBFBFFFLLL +FFFBBBFLRL +BFFBBBFRLL +BFFFFBBLRR +FFBBFFFRLL +BBFFBBBLLL +FFFBBFBRRL +BFFBFFBLRL +FFBFFFFRRL +FFBBFFFLRR +BFBBFFFRLR +BFBFFBBRLR +BBFBBFFLLR +BFFBFBBLRR +BBBFFFFLLR +FBBBFFFLRR +BBFBFFFRLL +FFBFBFBLLR +FFFBBFBRLL +BBFBBBFRLL +FBBBBFBLRL +FBFFBFFRRL +BFBFBFFRRR +BFBBBFBLLR +BFFBBFFRLR +FBFFFBFRRL +FBFBFFBLRL +FFBBFBBLRR +BFFBBFBLLR +FFFBBFBLRR +BFBFFBBLRL +FFBFBBFLRR +BFFFBFBRRR +BFBBFFFLLR +BBFFBFBLLL +BFFFBFFRLR +FBFBBFFRLR +FFBFBFBRRL +BBFBFBBRRL +FBBFBFBLRL +BFBFFBFRRL +BFBFFBFLLR +BFFFBBFRRR +BBFBBBBRRR +FBBFBBBRRR +FBBFBFBRLL +FFBFFBBLLR +BBFFBFBLRR +FBFFBBBLLR +BBFBFFBLRR +BBFBFFFRRL +BFFBBFBRLR +BBFFBBBRRL +FBBFFBFLRR +BFBBBFFRLL +BFFFBBFLLR +BFFBBBBLRR +BBFFBBFRRR +BFBFBBFLRR +FBFBFBBRLL +BBFFFFBRLR +FFBFBBBRRL +BBFBFBBRLR +FBFBFFFLLR +FBFBBBFLRR +FFBFBFFRRR +BFFBFFBRRR +BFFFFFFRRL +BFBFFBBRLL +FBFBFFFLRL +FFBBBFFRRL +BFFFFBBRLR +FFBFFFBLRR +FFBBFBFLRR +BBFFFBBRLR +FBFBBFFRLL +FFFBBFFLLL +FBBBFBBLRL +BBFFFFFLLR +BBFFFBFLRL +FBBBBBFLLL +FFFBFFFRRR +FBFBFBBRRR +BFBBFFBLRR +FBFBBBFRRL +FBBBFBFRLL +BBFFFBBRRL +FBFFBFBLLL +BFBBFBBLLL +FFBFFBFLLR +BBFBBFFRRL +FBFFFFBRLL +BFFFBBFLLL +FFFBFFBLRR +BFBBFFBLLL +FBBBBBBRLL +FFBBFFBLRL +BFBBBBBLRL +FBBBBFFLLR +BFFBBFBRLL +BFBFBFFLRL +BBFFFFFRRL +BFBFBFFLLL +FBFFBBFLRL +BBFBBFFRLL +BFBFFBBLLL +BFFFBFBLLR +BBBFFFBLLL +BBFBBBFLLL +FFBFBFFLRR +BFFFFFFLLL +BBFFBFBRRR +FFFBFBFRLR +FBBBFBFLLR +FFBFBFFLRL +BFBFBFBRRL +FBBFFBBRRR +BFFBBFFLRR +BFFBFBBLRL +FFBFFBBRLL +FBFBFFBLLR +BFFFFFFLLR +FFFFBBBLRR +FBFFFBFRRR +BFBBBFFRRR +BFBBFBBRLL +FFBFBFFRRL +BFFBFFBLLL +FFBBFFFLRL +FBBBBBBRLR +FBBBFBFLRR +FBFBFBBLRR +BFFFBBFRLR +FFBFBBFRRL +FBFFFBFLLR +BBFFBBFLRR +BBBFFFFLRL +BBBFFFFRRR +FBFFFFBRRL +BFBFFFBRRR +BFFFBFBRRL +FBFBFBBLRL +BFBFFFFLRL +FBFBBBBRRR +BFFFBBBRLR +FBBBFFBLRL +FFFBFBBRRL +FBBFBBFRRL +BFBBBFBRRL +FFBBFFFRLR +BBFBBFBLRL +FBFBBFBRLR +BBFFBFFRLL +FBBFBBBRRL +FBBFBBFRLL +BFBFBBFRRL +FFBFFFBLRL +BFFBFFFRLL +BFBFBBBRRL +FFBBFBFLRL +FBFBBBBLRL +BFFBBBFLRR +FFFFBBFRRR +FBFBBFFRRR +BFFFBFFRRL +BFBBFFFRLL +FFBBBFBLLR +BFBFFBFLRR +FBFBBFFLRR +FFBFBFFRLR +FBBBBFFLRL +FFFBBFFLRL +FBFBFFBRRL +BFBBFBFRRL +FBBFBFBRRL +FFFBBFFRLR +FFBFBFBRLR +FFBFFBBRLR +BBFFBFFLLL +BFBFFBBRRR +BFBBBBBRRL +BFBFFFBLRR +FBFBBFFRRL +BBFBFBFRLR +BFFFFFBLLR +FBBBFFBRRL +FBFFBBBLRR +BBFFFFBLLL +BFBFFFBLLR +FFBFBBBLLL +BFFFFBBRLL +BFFBBBBRRL +FBFBFBBRLR +FBFBBBFLLR +FFBFFBFLLL +BFBBFBFRLL +BFBBFFFRRR +BFBBFFBRRR +BFFBBFBLRL +BFFBBBBLRL +FFFBFFFLRR +BFBBFFBLLR +FFFBFFBRRL +BFBBBBFRLL +FFBBFBFRLR +FBBBFBBLLL +BBBFFFFLLL +BBFFFFBLRL +BBFBFFBRLR +BFBFBBFLRL +FFFBFFBRLR +FFFBFBFRLL +BBFFFFBLLR +BFBFBFBRLR +FBFBBFBLRR +BBFFFBBLLR +FBFBBBFLLL +BFFFBFFRRR +BBFBFFBLLR +BFFBFBBRRL +FBBBBFFRRR +BFFFFBBRRR +FFBBBFBLRL +BFBBBBBLLR +FFBBFFFRRR +FFFBBBBLLL +FBBBBFBRLR +BBBFFFBLRL +FBFBFBFLRR +BFFBFFBRLL +BFFBBBBRLL +BBFFBFBRRL +FFBFBBFRRR +FBFFBFBRRL +BFBBBFFLLL +FBBBFFFRRR +FBBBBBFLRL +FBBFBBFLRL +FFBFFFFRRR +FFFFBBBLRL +FBFBBFBRRL +BBBFFFFLRR +FFFBFBBLRR +BBFFBFBRLL +FFBBFFBRRR +FBFFBFFRLL +FFBFFBFRRL +FBFBFFFRRR +BFFBFFFLLR +BFBBFBBRRL +FFFBFBFRRL +BFBBBBFLLR +BFFFBFFLRR +FBBFFFBLRL +BFFFFBBLLR +BFBFBFFLRR +FFBBBBFLRR +FBBBBFFLRR +FBBBBFBRRL +BBFFFFFRLR +FBFFFBBLLR +FFFBBBFRRR +BBFFFBBRRR +FBBFBFBRRR +FBBBBBBLRR +FFFBFBBLRL +BFBFFFBLLL +FFBBFBFLLR +FFBBBBFRRR +FBFFBBBRLR +FBFBFFBLRR +BBFFBFBLRL +FBFFBFBRRR +BFBFBBBLRL +FFFBBBFRRL +BFBBBFFLRL +BBFFBFFRRL +FFFBBFFRRL +BFBFFBBLRR +BBFFFBBLLL +BFBBBFBLRL +BFFBFFBLLR +BFBFFFFRLR +FFBBBBBLLR +BFFBBBBRRR +FBBFFBBLLL +FBFBFBFRRR +FBFBBFBLLR +FBBFFBBRRL +FFBFBFBLLL +BFFFBFBLRR +FBFBBBBRRL +FBFFBFBLRR +FBFFBBBRRL +FFBFBBBRLR +BBFFFFBLRR +FBFFFBBRLL +FFBBFBFRRR