anchor.diff:      let numbers = (Seq.head input).Split(',') |> Seq.map (fun x -> int x)
       let boards = input |> Seq.tail |> parseBoards
   
  -    let fastestBoard = 
  -        boards |> 
  -        Seq.map (fun board -> (neededNumbersForBoard numbers board, board)) |> 
  -        Seq.minBy fst
  -    
  -    let lastRequiredNumber = (numbers |> List.ofSeq)[(fst fastestBoard) - 1]
  -    let sumOfUnused = (sumUnmarkedNumbers (numbers |> Seq.take (fst fastestBoard)) (snd fastestBoard))
  +    // This is a quite slow calculation.. So i'm sure it can be done in a better way
  +
  +    let (lastRequiredNumber, sumOfUnused) = findLastRequiredAndSumOfUnused numbers boards Seq.minBy
   
       //printfn "Sum %A" sumOfUnused
       //printfn "Board: %A" (snd fastestBoard)
  
positive.code:     let result = findRequired numbers (row |> List.ofSeq) 0
      result
  
  let neededNumbersForBoard (numbers : int seq) (board : (int) seq seq) =
      let rec red rows (required: int) =
          match rows with 
          | [] -> required
  
negative.code:     let result = min horizontalResult verticalResult
      result
  
  
  let sumUnmarkedNumbers usedNumbers board =
      board |> Seq.collect (fun x -> x) |> Seq.except usedNumbers |> Seq.sum<int>
  
  let findLastRequiredAndSumOfUnused numbers boards comparer =
      let board = 
          boards |> 
          Seq.map (fun board -> (minNeededNumbersForBoard numbers board, board)) |> 
          comparer fst
      
      let lastRequiredNumber = (numbers |> List.ofSeq)[(fst board) - 1]
      let sumOfUnused = (sumUnmarkedNumbers (numbers |> Seq.take (fst board)) (snd board))
      (lastRequiredNumber, sumOfUnused)
  
  let execute (input : string seq) =
      printfn "Input count: %i" (Seq.length input)
  