anchor.diff:  // I tried my luck with a Map and a single iteration of each point of each line... It works.. But 
   // this is also super inefficient, even though I would have assumed otherwise.. Hmm.
   
  -
   let addLineToMap (line:Point[], map:Map<Point, int>) =
       let increment x = 
  -        let fdsfs = match x with 
  -                    | Some x -> Some(x + 1)
  -                    | None -> Some(1)
  -        fdsfs
  +        match x with 
  +        | Some x -> Some(x + 1)
  +        | None -> Some(1)
       
  -    
  -
       let rec addPoints (points, map:Map<Point, int>) =
  -        //let timer = new Stopwatch()
  -        //timer.Start()
  -        //printfn "   Points: %A" points
  -        let res = match points with 
  -                    | x when Seq.isEmpty x -> map
  -                    | _ -> addPoints ((Seq.tail points), (map.Change((Seq.head points), increment)))
  -        //timer.Stop()
  -        //printfn "%A" timer.Elapsed
  -        res
  +        match points with 
  +        | x when Seq.isEmpty x -> map
  +        | _ -> addPoints ((Seq.tail points), (map.Change((Seq.head points), increment)))
   
       let generatePoints line =
  -        let res = match line with 
  -                    | x when isHorizontal x -> 
  -                        Enumerable.Range(minX line, (maxX line - minX line + 1)) |> 
  -                        Seq.map (fun x -> new Point(line[0].Y, x))
  -                    | x when isVertical x -> 
  -                        Enumerable.Range(minY line, (maxY line - minY line + 1)) |> 
  -                        Seq.map (fun y -> new Point(y,line[0].X))
  -                    | _ -> Seq.empty
  -        res
  +        match line with 
  +        | x when isHorizontal x -> 
  +            Enumerable.Range(minX line, (maxX line - minX line + 1)) |> 
  +            Seq.map (fun x -> new Point(line[0].Y, x))
  +        | x when isVertical x -> 
  +            Enumerable.Range(minY line, (maxY line - minY line + 1)) |> 
  +            Seq.map (fun y -> new Point(y,line[0].X))
  +        | _ -> Seq.empty
   
  -    //printfn "LINE: %A" line
  -
  -    let timer = new Stopwatch()
  -    timer.Start()
       let result = addPoints ((generatePoints line), map)
  -    
  -    timer.Stop()
  -    printfn "%A" timer.Elapsed
   
       result
           
   let solvePart1WithMap (lines:Point[] seq) =
       let rec addLinesToMap (lines:Point[] seq, map) =
  -        //printfn "Adding %A to map" (Seq.head lines)
           match lines with 
           | x when Seq.isEmpty x -> map
           | _ -> addLinesToMap ((Seq.tail lines), (addLineToMap ((Seq.head lines), map)))
  
positive.code:     let part1Lines = 
          parsed |>
          Seq.filter (fun x -> x[0].X = x[1].X || x[0].Y = x[1].Y)
  
      let overlapCount = solvePart1WithMap part1Lines
      //let overlapCount = countAllOverlapping part1Lines
  
      let part1 = overlapCount
  
  
negative.code: 
      positionCount.Values |> Seq.filter (fun x -> x > 1) |> Seq.length
  
  // In my pursuit of knowledge I found this solution https://github.com/jovaneyck/advent-of-code-2021/blob/main/day%2005/part1.fsx
  // which is using lots of stuff I have no idea how works.. 
  // The below solution is that one which has the performance I would expect.
  
  let solvePart1WithCountBy (lines:(Point * Point) seq) =
      let generatePoints (first:Point, second:Point) =
          let [ min_x; max_x ] = [first.X; second.X] |> List.sort
          let [ min_y; max_y ] = [first.Y; second.Y] |> List.sort
  
          let points = [ for x in min_x .. max_x do 
                          for y in min_y .. max_y -> (x,y)] // This works because either x or y will be the same. Wont work for diagonal
          
          points
      
      lines |> 
          Seq.collect generatePoints |> 
          Seq.countBy id |> 
          Seq.filter (fun (_, count) -> count > 1) |>
          Seq.length
  
  let execute (input : string seq) =
      printfn "Input count: %i" (Seq.length input)
  