anchor.diff:      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>) =
  
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: 
  module Yard.Generators.ARNGLR.Parser
  
  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.DataStructures
  open Yard.Generators.RNGLR
  
  type ParseResult<'TokenType> =
      | Success of Tree<'TokenType>
      | Error of int * 'TokenType * string
  
  [<AllowNullLiteral>]
  type Vertex (state : int, level : int) =
  