day 4 and 5

day4.ml

@@ -0,0 +1,91 @@
+(* Common util. Should probably put this in a module or something.. *)
+let get_one_line file =
+  try Some (input_line file) with
+    End_of_file -> None
+
+let get_lines file =
+  let rec input lines =
+    match get_one_line file with
+      Some line -> input (line :: lines)
+    | None -> List.rev lines
+  in input []
+
+let read_file file =
+  let channel = open_in(file) in
+  get_lines channel
+
+let explode s = (* convert a string to a list of chars *)
+  let rec exp i l =
+   if i < 0 then l else exp (i - 1) (s.[i] :: l) in
+  exp (String.length s - 1) []
+
+let implode l = String.of_seq (List.to_seq l)
+
+(* --- *)
+
+let fix_lines lines = (* puts each passport on 1 line *)
+  let glue s = if String.equal s "" then "\n" else " " in (* which char to concat the lines *)
+  let fix_line acc cur = acc ^ (glue cur) ^ cur in (* our reducer: concat lines with either space or newline *)
+  List.fold_left fix_line "" lines
+
+let read_passport line = (* converts a line to an alist *)
+  let chunks = String.(split_on_char ' ' (trim line)) in (* split each string on space *)
+  let read_chunk chunk =
+    let parts = String.split_on_char ':' chunk in (* split each chunk on colon *)
+    List.(nth parts 0, nth parts 1) in (* return a tuple for each chunk *)
+  List.map read_chunk chunks
+
+let required_fields = ["byr"; "iyr"; "eyr"; "hgt"; "hcl"; "ecl"; "pid";]
+
+let passport_has_required_fields passport =
+  let has_key key = (* does a passport have a particular key *)
+    match List.assoc_opt key passport with
+    | Some _ -> true
+    | _ -> false
+  in
+  List.for_all has_key required_fields (* does it have ALL the keys *)
+
+let is_in_range (min, max) n = int_of_string n >= min && int_of_string n <= max
+
+let is_height_valid h =
+  let len = String.length h in
+  let units = String.sub h (len - 2) 2 in
+  let value = String.sub h 0 (len - 2) in
+  match units with
+  | "cm" -> is_in_range (150, 193) value
+  | "in" -> is_in_range (59, 76) value
+  | _ -> false
+
+let is_char_hex c =
+  let hex_chars = "0123456789abcdef" in
+  String.contains hex_chars c
+
+let is_hair_valid h =
+  let color = (String.sub h 1 (String.length h - 1)) in
+  String.length h = 7 &&
+  String.sub h 0 1 = "#" &&
+  List.for_all is_char_hex (explode color)
+
+let is_eye_color_valid c =
+  List.mem c ["amb"; "blu"; "brn"; "gry"; "grn"; "hzl"; "oth";]
+
+let is_pid_valid p =
+  String.length p = 9 &&
+  List.for_all (fun c -> List.mem c (explode "0123456789")) (explode p)
+
+let is_passport_valid p =
+  is_in_range (1920, 2002) (List.assoc "byr" p) &&
+  is_in_range (2010, 2020) (List.assoc "iyr" p) &&
+  is_in_range (2020, 2030) (List.assoc "eyr" p) &&
+  is_height_valid (List.assoc "hgt" p) &&
+  is_hair_valid (List.assoc "hcl" p) &&
+  is_eye_color_valid (List.assoc "ecl" p) &&
+  is_pid_valid (List.assoc "pid" p)
+
+let lines = read_file "day4.txt" |> fix_lines |> String.split_on_char '\n'
+let passports = List.map read_passport lines
+let passports_with_required_fields = List.filter passport_has_required_fields passports
+let valid_passports = List.filter is_passport_valid passports_with_required_fields;;
+
+Printf.printf "Number of passports with all required fields: %i\n" (List.length passports_with_required_fields);;
+Printf.printf "Number of valid passports: %i\n" (List.length valid_passports);;

day5.ml

@@ -0,0 +1,76 @@
+(* Common util. Should probably put this in a module or something.. *)
+let get_one_line file =
+  try Some (input_line file) with
+    End_of_file -> None
+
+let get_lines file =
+  let rec input lines =
+    match get_one_line file with
+      Some line -> input (line :: lines)
+    | None -> List.rev lines
+  in input []
+
+let read_file file =
+  let channel = open_in(file) in
+  get_lines channel
+
+let explode s = (* convert a string to a list of chars *)
+  let rec exp i l =
+   if i < 0 then l else exp (i - 1) (s.[i] :: l) in
+  exp (String.length s - 1) []
+
+let implode l = String.of_seq (List.to_seq l)
+
+let range start len = (* makes a new list from start with length len *)
+  List.init len (fun x -> x + 1) |> List.map (fun x -> x + start)
+
+(* --- *)
+
+type 'a tree = Leaf of 'a | Node of 'a tree * 'a tree
+
+let rec build_tree l = (* build a balanced tree from a list *)
+  match l with (* exception for [] would probably be good here.. *)
+  | x::[] -> Leaf x
+  | x::xs ->
+      let len = List.length l in
+      let mid_val = List.nth l (len/2) in
+      let left = range (x-1) (len/2) in
+      let right = range (mid_val-1) (len/2) in
+      Node (build_tree left, build_tree right)
+
+let rec walk tree steps =
+  match tree with
+  | Leaf a -> a (* if we've hit a leaf, return the value *)
+  | Node (l, r) ->
+      match steps with (* if we get to the end of theh list and we haven't hit a leaf, that's a problem.. if only i knew how to do exceptions *)
+        | 'F' :: xs -> walk l xs
+        | 'L' :: xs -> walk l xs
+        | 'B' :: xs -> walk r xs
+        | 'R' :: xs -> walk r xs
+
+let rows = build_tree (range 0 128)
+let cols = build_tree (range 0 8)
+
+let find_seat map =
+  let row = walk rows (explode (String.sub map 0 7)) - 1 in (* one-off b/c of their non-0-indexed lists? *)
+  let col = walk cols (explode (String.sub map 7 3)) - 1 in
+  (row, col)
+
+let seat_id (row, col) = row * 8 + col
+
+let rec list_max li =
+  match li with (* again non exhaustive, empty list fails. be better *)
+  | x :: [] -> x
+  | x :: xs -> max x (list_max xs)
+
+let rec find_missing seats =
+  match seats with
+  | x :: y :: z -> if y = x + 1 then find_missing (y :: z) else x + 1
+  | x :: [] -> x
+
+let seats = read_file "day5.txt" |> List.map find_seat
+let seat_ids = List.map seat_id seats
+let sorted_seats = List.sort (fun a b -> if a > b then 1 else if a < b then -1 else 0) seat_ids;;
+
+Printf.printf "max seat id %i\n" (list_max seat_ids);;
+Printf.printf "missing seat %i\n" (find_missing sorted_seats);;

day5.txt

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