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:         | Some x -> Some(x + 1)
          | None -> Some(1)
      
      // Original implementation used Seq instead of Lists. Turns out Seq is not that good for recursive
      // functions like this, since you will likely have to evaluate the entire sequence every time (and 
      // not just parse an continuous iterator as I naively assumed it would)
      // Changing this function to use lists let me solve Part 1 in ~0.5 seconds (compared to the ~1.5 
      // minutes before)
      let rec addPoints (points, map:Map<Point, int>) =
          match points with 
          | [] -> map
          | _ -> addPoints ((List.tail points), (map.Change((List.head points), increment)))
  
      let generatePoints line =
          match line with 
  