anchor.diff:              if newVertex.FindIndex reduction.gssVertex.State reduction.gssVertex.Level = -1 
               then
                   let edge = new Edge(reduction.gssVertex, -parserSource.LeftSide.[reduction.prod]-1)
  -                addEdge currentGraphV isNew newVertex edge false
  +                addEdge customEnqueue currentGraphV isNew newVertex edge false
           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<_>) =
  +            walk customEnqueue (reduction.pos - 1) (reduction.edge.Value : Edge).Dest path currentGraphV nonTerm reduction.pos reduction.prod false
  +
  +    let makeReductions customEnqueue (currentGraphV : VInfo<_>) =
           while currentGraphV.reductions.Count > 0 do
               let r = currentGraphV.GetReduction()
  -            makeSingleReduction currentGraphV r
  -
  -
  -    let handlePassingReductions (graphV : VInfo<_>) =
  +            makeSingleReduction customEnqueue currentGraphV r
  +
  +
  +    let handlePassingReductions customEnqueue (graphV : VInfo<_>) =
           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
                   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
  +                walk customEnqueue (remainLength - 1) e.Dest newPath startV nonTerm pos prod true
               graphV.passingReductions.Remove((v, e)) |> ignore
   
  -    let processVertex v = 
  -        makeReductions v
  +    let processVertex customEnqueue v = 
  +        makeReductions customEnqueue v
   
           let newGssVs = new ResizeArray<_>(2)
           for gssVertex in v.unprocessedGssVertices do 
  -            newGssVs.AddRange(push v gssVertex)
  +            newGssVs.AddRange(push customEnqueue v gssVertex)
           v.unprocessedGssVertices.Clear()
           if newGssVs.Count > 0 
           then
  
positive.code:         let ast = 
              match newVertex.FindIndex final.State final.Level with
              | -1 -> 
                  let edge = new Edge(final, nodes.Length)
                  nodes.Add <| new AST (Unchecked.defaultof<_>, null)
                  addEdge  startV isNew newVertex edge (pos > 0)
                  edge.Ast
              | x -> (newVertex.Edge x).Ast 
          if ast >= 0 
          then addChildren nodes.[ast] path prod
          else 
              let edge = new Edge(final, nodes.Length)
              nodes.Add <| new AST (Unchecked.defaultof<_>, null)
              addEdge  startV isNew newVertex edge (pos > 0)
              addChildren nodes.[nodes.Length - 1] path prod
  
      let rec walk remainLength (vertex : Vertex) path startV nonTerm pos prod shouldEnqueueVertex = 
          if remainLength = 0 
          then handlePath path vertex startV nonTerm pos prod shouldEnqueueVertex
          else
              if not (ResizeArray.exists 
                         (fun (_prod, _remainLength, _path : Path, _nonTerm, _pos, _startV) ->
  
negative.code:             for e in outEdgesInnerGraph.[startV.vNum] do
                  addNonZeroReduction newVertex e.Tag edge startV
  
      let edgesToTerms = new System.Collections.Concurrent.ConcurrentDictionary<_,_>()
      let push customEnqueue (currentGraphV:VInfo<_>) (gssVertex : Vertex) =
          let newUnprocessedGssVs = new ResizeArray<_>(2)
          for e in outEdgesInnerGraph.[currentGraphV.vNum] do
              let push = parserSource.Gotos.[gssVertex.State].[parserSource.TokenToNumber e.Tag]
  