anchor.diff:  let minByY (line:Point[]) = Array.minBy (fun (x:Point) -> x.Y)
   let maxByY (line:Point[]) = Array.minBy (fun (x:Point) -> x.Y)
   
  -// I originally wanted to do a recursive function that checked every line against every other line
  -// which was super inefficient. It didn't give me the correct result, so instead of debugging it 
  -// 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.
  +// 1. I originally wanted to do a recursive function that checked every line against every other line
  +//    which was super inefficient. It didn't give me the correct result, so instead of debugging it 
  +//    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.
  +
  +// 2. Found out why it's super slow. See comment over `addPoints`
   
   let addLineToMap (line:Point[], map:Map<Point, int>) =
       let increment x = 
  
positive.code: open System.Linq
  open System.Diagnostics
  
  // Task 1: Find number of points were a horizontal/ vertical line overlaps
  // Task 2: 
  type Point = 
      struct 
  
negative.code: 
      positionCount.Values |> Seq.filter (fun x -> x > 1) |> Seq.length
  
  // I was a bit stuck trying to figure out why my solution was so slow, so I looked up other solutions and found this: 
  // 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 and has the performance I would expect.
  
  let solvePart1WithCountBy (lines:(Point * Point) seq) =
      let generatePoints (first:Point, second:Point) =
  