anchor.diff:                      path.[remainLength - 1] <- if e.Ast < 0 then new Epsilon(e.Ast) :> AstNode else nodes.[e.Ast]
                       walk (remainLength - 1) e.Dest path currentGraphV startV nonTerm pos prod shouldEnqueueVertex)
   
  -    let makeSingleReduction currentGraphV (vertex : Vertex) prod pos (edgeOpt : Edge option) =
  -        let nonTerm = parserSource.LeftSide.[prod]
  -
  -        if pos = 0 then
  -            let state = parserSource.Gotos.[vertex.State].[nonTerm]
  +    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 None
  -            if newVertex.FindIndex vertex.State vertex.Level = -1 then
  -                let edge = new Edge(vertex, -parserSource.LeftSide.[prod]-1)
  +            if newVertex.FindIndex reduction.gssVertex.State reduction.gssVertex.Level = -1 then
  +                let edge = new Edge(reduction.gssVertex, -parserSource.LeftSide.[reduction.prod]-1)
                   newVertex.addEdge edge
           else 
  -            let path = Array.zeroCreate pos
  -            path.[pos - 1] <- nodes.[edgeOpt.Value.Ast]
  -            walk (pos - 1) (edgeOpt.Value : Edge).Dest path currentGraphV currentGraphV nonTerm pos prod false
  +            let path = Array.zeroCreate reduction.pos
  +            path.[reduction.pos - 1] <- nodes.[reduction.edge.Value.Ast]
  +            walk (reduction.pos - 1) (reduction.edge.Value : Edge).Dest path currentGraphV currentGraphV nonTerm reduction.pos reduction.prod false
   
       let makeReductions (currentGraphV : VInfo<_>) =
           while currentGraphV.reductions.Count > 0 do
  -            let vertex, prod, pos, edgeOpt = currentGraphV.reductions.Dequeue()
  -            makeSingleReduction currentGraphV vertex prod pos edgeOpt
  +            let r = currentGraphV.reductions.Dequeue()
  +            makeSingleReduction currentGraphV r
   
   
       let handlePassingReductions (graphV : VInfo<_>) =
  
positive.code:                     let arr = parserSource.ZeroReduces.[push].[parserSource.TokenToNumber e2.Tag]
                      if arr <> null then
                          for prod in arr do
                              reductions.Add(targetGssV, prod, 0, None, e.Target)
  
                      let arr = parserSource.Reduces.[push].[parserSource.TokenToNumber e2.Tag]
                      if arr <> null then
                          for (prod, pos) in arr do
                              //printf "%A %A %d %d\n" v.label v.outEdges prod pos
                              reductions.Add(gssVertex, prod, pos, Some edge, e.Target)
  
              let arr = parserSource.ZeroReduces.[state].[parserSource.TokenToNumber e.Tag]
              if arr <> null then
                  verticesToProcess.Enqueue currentGraphV
                  for prod in arr do
                      reductions.Add(gssVertex, prod, 0, None, currentGraphV)
          
          let reductionSet = new ResizeArray<_>(10)
          for gssVertex, prod, pos, edge, target in reductions do
              let reductionExists = 
                  reductionSet
                  |> ResizeArray.exists(function v, p, _pos, e, target -> v = gssVertex && p = prod && _pos = pos && edge = e)
              if not reductionExists then reductionSet.Add(gssVertex, prod, pos, edge, target)
          for gssVertex, prod, pos, edge, target in reductionSet do
              let r = gssVertex, prod, pos, edge
              let reds = target.reductions
              target.reductions.Enqueue(r)
          
          currentGraphV.processedGssVertices.Add(gssVertex)
  
negative.code:     member val processedGssVertices = new ResizeArray<Vertex>() with get
      member val unprocessedGssVertices = new ResizeArray<Vertex>() with get
  
  and [<Struct>]
      Reduction =
      val gssVertex : Vertex
      val prod : int
      val pos : int
      val edge : Edge option
      new (_gssVertex, _prod, _pos, _edge) = {gssVertex = _gssVertex; prod = _prod; pos = _pos; edge = _edge}
  
  [<AllowNullLiteral>]
  type Path (first : int, tail : int, paths : ResizeArray<Path>) =
  