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:                           Seq.pairwise |> 
                            Seq.map (fun (x,y) -> new Point(int x,int y)) |> 
                            Seq.head)
  
  let isHorizontal (line:Point[]) = line[0].Y = line[1].Y
  let isVertical (line:Point[]) = line[0].X = line[1].X
  
negative.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 parsed = input |> Seq.map parseLine2
      //let part1Lines = 
      //    parsed |>
      //    Seq.filter (fun x -> (fst x).X = (snd x).X || (fst x).Y = (snd x).Y)
      //let overlapCount = solvePart1WithCountBy part1Lines
  
      let part1 = overlapCount
  
  