anchor.diff:                      addZeroReduction v state e.Tag currentGraphV false
           v, isNew
   
  +    let addEdge (startV:VInfo<_>) isNew (newVertex:Vertex) edge isNotEps =
  +        if not isNew && newVertex.PassingReductions.Count > 0
  +        then startV.passingReductions.Add((newVertex, edge))
  +        newVertex.addEdge edge
  +        if isNotEps
  +        then
  +            for e in outEdgesInnerGraph.[startV.vNum] do
  +                addNonZeroReduction newVertex newVertex.State e.Tag edge startV
  +
       let edgesToTerms = new Dictionary<_,_>()
       let push (currentGraphV:VInfo<_>) gssVertex state =
           let newUnprocessedGssVs = new ResizeArray<_>(2)
  
positive.code:         for (v, e) in copyPR do
              let passingReductions = v.PassingReductions
              for prod, remainLength, path, nonTerm, pos, startV in passingReductions do
                  let newPath = path.AddEdge(if e.Ast < 0 then new Epsilon(e.Ast) :> AstNode else nodes.[e.Ast])
                  walk (remainLength - 1) e.Dest newPath startV nonTerm pos prod true
              graphV.passingReductions.Remove((v, e)) |> ignore
  
  
negative.code: 
      let verticesToRecalc = new ResizeArray<_> (10)
  
      let (*inline*) addChildren index (path : Path) prod =
          let ast = 
              match nodes.[index] with
              | :? Epsilon as eps -> let wrappedEps = new AST (new Family(-eps.EpsilonNonTerm-1, new Nodes([|eps|])), null)
                                     nodes.Set index wrappedEps
                                     wrappedEps
              | :? AST as ast -> ast
              | _ -> failwith ""
          
          //let ast = getFamily node
          let familyOpt = 
              ast.findFamily (function family -> family.prod = prod && path.IsEqual(family.nodes))
          match familyOpt with 
  