anchor.diff:  
       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)
  
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: // 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 = 
          match x with 
          | Some x -> Some(x + 1)
          | None -> Some(1)
      
      let rec addPoints (points, map:Map<Point, int>) =
          match points with 
          | x when Seq.isEmpty x -> map
          | _ -> addPoints ((Seq.tail points), (map.Change((Seq.head points), increment)))
  
      let generatePoints line =
          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
  
      let result = addPoints ((generatePoints line), map)
  
      result
          
  let solvePart1WithMap (lines:Point[] seq) =
      let rec addLinesToMap (lines:Point[] seq, map) =
          match lines with 
          | x when Seq.isEmpty x -> map
          | _ -> addLinesToMap ((Seq.tail lines), (addLineToMap ((Seq.head lines), map)))
  