anchor.diff:                  runner <- Option.get dom.[runner]
               ds
   
  -    let inter poMap (dom: DominationTree) b1 b2 =
  -        //printfn "      intersection with : %s, %s" (string b1) (string b2)
  -        //for kv in dom do 
  -        //    let state = kv.Key
  -        //    let value = kv.Value
  -        //    printfn "      key: %s, value: %s" (string state) (string value)
  +    let inter (po: Dictionary<CgState,int>) (dom: DominationTree) b1 b2 =
           let mutable finger1 = b1
           let mutable finger2 = b2
  -        while (Map.find finger1 poMap <> Map.find finger2 poMap) do 
  -            while (Map.find finger1 poMap > Map.find finger2 poMap) do 
  +        while (po.[finger1] <> po.[finger2]) do 
  +            while (po.[finger1] > po.[finger2]) do 
                   finger1 <- Option.get dom.[finger1]
  -            while (Map.find finger2 poMap > Map.find finger1 poMap) do
  +            while (po.[finger2] > po.[finger1]) do
                   finger2 <- Option.get dom.[finger2]
  -        //printfn "      intersected node is: %s" (string finger1)
           finger1
   
       let dominators' (cg: T) root direction : DominationSet = 
  -        //printfn "\n\n"
           let f = if direction = Up then neighbors else neighborsIn
           let dom = Dictionary()
           let postorder = 
               Reachable.dfs cg root direction
               |> Seq.mapi (fun i n -> (n,i))
  -        let postorderMap = Map.ofSeq postorder
  +        let postorderMap = Dictionary() 
  +        Seq.iter (fun (n,i) -> postorderMap.[n] <- i) postorder
           let allNodes = cg.Graph.Vertices |> Set.ofSeq
           for b in allNodes do 
               dom.[b] <- None
  
positive.code:                 assert (ie.Target = e.Source)
                  (Set.contains e.Target (dom.[e.Source]) || Set.contains e.Source (domRev.[e.Target])) &&
                  not (e.Target = e.Source) ) |> ignore
          (* Remove nodes dominated by a similar location *)
          cg.Graph.RemoveVertexIf (fun v -> 
              dom.[v]
              |> Set.exists (fun u -> u <> v && u.Node.Loc = v.Node.Loc)) |> ignore
          (* Remove edges where the outgoing is dominated by a similar location *)
          cg.Graph.RemoveEdgeIf (fun e ->
              let x = e.Source
              let y = e.Target
              Set.exists (fun x' -> x'.Node.Loc = x.Node.Loc && x' <> x) domRev.[y]
          ) |> ignore
  
      let removeDeadEdgesHeuristic (cg: T) =
          cg.Graph.RemoveEdgeIf (fun (e: TaggedEdge<CgState,unit>) -> 
  
negative.code:     let removeDominated (cg: T) = 
          let dom = dominators' cg cg.Start Down
          let domRev = dominators' cg cg.End Up
          // Remove dominated edges
          cg.Graph.RemoveEdgeIf (fun (e: TaggedEdge<CgState,unit>) -> 
              let ies = cg.Graph.OutEdges e.Target
              match Seq.tryFind (fun (ie: TaggedEdge<CgState,unit>) -> ie.Target = e.Source) ies with 
  