anchor.diff:  
   
       let handlePassingReductions (graphV : VInfo<_>) =
  -        verticesToRecalc.Clear()
  -        for gssV in graphV.processedGssVertices do
  -            let passingReductions = gssV.PassingReductions
  +        let copyPR = ResizeArray.copy(graphV.passingReductions)
  +        for (v, e) in copyPR do
  +            let passingReductions = v.PassingReductions
               for prod, remainLength, path, nonTerm, pos, startV in passingReductions do
  -                walk remainLength gssV path graphV startV nonTerm pos prod true
  -        verticesToRecalc
  +                walk remainLength v path startV nonTerm pos prod true
  +            graphV.passingReductions.Remove((v, e)) |> ignore
   
       let processVertex v = 
           makeReductions v
  
positive.code:                 if startV.reductions.Count > 0 then customEnqueue startV
              addChildren nodes.[nodes.Count - 1] path prod
  
      let rec walk remainLength (vertex : Vertex) path currentGraphV startV nonTerm pos prod shouldEnqueueVertex = 
          if remainLength = 0 
          then handlePath path vertex currentGraphV startV nonTerm pos prod shouldEnqueueVertex
          else
              if not (ResizeArray.exists 
                         (fun (_prod, _remainLength, _path : Path, _nonTerm, _pos, _startV) ->
  
negative.code:             vertex.OutEdges |> ResizeArray.iter
                  (fun e ->
                      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 shouldEnqueueVertex)
  
      let makeSingleReduction currentGraphV (reduction : Reduction) =
          let nonTerm = parserSource.LeftSide.[reduction.prod]
  
          if reduction.pos = 0 then
              let state = parserSource.Gotos.[reduction.gssVertex.State].[nonTerm]
              let newVertex, isNew = addVertex currentGraphV state
              if newVertex.FindIndex reduction.gssVertex.State reduction.gssVertex.Level = -1 then
                  let edge = new Edge(reduction.gssVertex, -parserSource.LeftSide.[reduction.prod]-1)
                  if not isNew
                  then currentGraphV.passingReductions.Add((newVertex, edge))
                  newVertex.addEdge edge
          else 
              let path = new Path(nodes.[reduction.edge.Value.Ast])
              walk (reduction.pos - 1) (reduction.edge.Value : Edge).Dest path currentGraphV nonTerm reduction.pos reduction.prod false
  
      let makeReductions (currentGraphV : VInfo<_>) =
          while currentGraphV.reductions.Count > 0 do
  