anchor.diff:  
   module Yard.Generators.ARNGLR.Parser
   
  -open Yard.Generators.RNGLR
  +open AbstractAnalysis.Common
  +open Microsoft.FSharp.Collections
  +open System.Collections.Generic
   open Yard.Generators.Common.AST
   open Yard.Generators.Common.AstNode
  -//open Yard.Generators.Common.ARNGLR.SimpleAST
  -open System.Collections.Generic
   open Yard.Generators.Common.DataStructures
  -//open Yard.Generators.RNGLR.Parser 
  -open Microsoft.FSharp.Collections
  -open AbstractAnalysis.Common
  +open Yard.Generators.RNGLR
   
   type ParseResult<'TokenType> =
       | Success of Tree<'TokenType>
       | Error of int * 'TokenType * string
  -
  -[<Struct>]
  -type Item =
  -    val prod : int
  -    val pos : int
  -    new (_prod, _pos) = {prod = _prod; pos = _pos}
   
   [<AllowNullLiteral>]
   type Vertex (state : int, level : int) =
  
positive.code:                     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 newVertex, isNew = addVertex currentGraphV state None
              if newVertex.FindIndex vertex.State vertex.Level = -1 then
                  let edge = new Edge(vertex, -parserSource.LeftSide.[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 makeReductions (currentGraphV : VInfo<_>) =
          while currentGraphV.reductions.Count > 0 do
              let vertex, prod, pos, edgeOpt = currentGraphV.reductions.Dequeue()
              makeSingleReduction currentGraphV vertex prod pos edgeOpt
  
  
      let handlePassingReductions (graphV : VInfo<_>) =
  
negative.code:                         let arr = parserSource.Reduces.[state].[parserSource.TokenToNumber e.Tag]
                          if arr <> null then
                              for (prod, pos) in arr do
                                  currentGraphV.reductions.Enqueue(new Reduction(newVertex, prod, pos, Some edge))
                  edge.Ast
              | x -> (newVertex.Edge x).Ast
          addChildren nodes.[ast] (Microsoft.FSharp.Collections.Array.copy path) prod
  