anchor.diff:      let removeDominated (cg: T) = 
           let dom = dominators' cg cg.Start Down
           let domRev = dominators' cg cg.End Up
  -        (* Remove dominated edges *)
  +        // 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 
  
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:                 runner <- Option.get dom.[runner]
              ds
  
      let inter (po: Dictionary<CgState,int>) (dom: DominationTree) b1 b2 =
          let mutable finger1 = b1
          let mutable finger2 = b2
          while (po.[finger1] <> po.[finger2]) do 
              while (po.[finger1] > po.[finger2]) do 
                  finger1 <- Option.get dom.[finger1]
              while (po.[finger2] > po.[finger1]) do
                  finger2 <- Option.get dom.[finger2]
          finger1
  
      let dominators' (cg: T) root direction : DominationSet = 
          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 = 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
  