anchor.diff:                  else ast.other <- Array.append ast.other [|newFamily|]
           | Some _ -> ()
   
  -    let handlePath (path : Path) (final : Vertex) currentGraphV startV nonTerm pos prod shouldEnqueueVertex =
  +    let handlePath (path : Path) (final : Vertex) startV nonTerm pos prod shouldEnqueueVertex =
           let state = parserSource.Gotos.[final.State].[nonTerm]
  -        let newVertex, isNew = addVertex startV state None
  -        if shouldEnqueueVertex && isNew then verticesToRecalc.Add startV
  +        let newVertex, isNew = addVertex startV state
  +        if shouldEnqueueVertex && isNew 
  +        then
  +            verticesToRecalc.Add startV
           let ast = 
               match newVertex.FindIndex final.State final.Level with
               | -1 -> 
                   let edge = new Edge(final, nodes.Count)
                   nodes.Add <| new AST (Unchecked.defaultof<_>, null)
  +                if not isNew
  +                then startV.passingReductions.Add((newVertex, edge))
                   newVertex.addEdge edge
                   if (pos > 0)
                   then
  -                    for e in innerGraph.OutEdges currentGraphV do
  +                    for e in innerGraph.OutEdges startV do
                           let arr = parserSource.Reduces.[state].[parserSource.TokenToNumber e.Tag]
                           if arr <> null then
                               for (prod, pos) in arr do
  -                                currentGraphV.AddReduction(new Reduction(newVertex, prod, pos, Some edge))
  +                                startV.AddReduction(new Reduction(newVertex, prod, pos, Some edge))
                   edge.Ast
               | x -> (newVertex.Edge x).Ast 
           if ast >= 0 
  
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:             currentGraphV.processedGssVertices.Add(gssVertex)
          newUnprocessedGssVs
  
      let (*inline*) addVertex (currentGraphV:VInfo<_>) state =
          let mutable v = null
          let mutable isNew = false
          let vOpt = currentGraphV.processedGssVertices |> ResizeArray.tryFind (fun v -> v.State = state)
  