anchor.diff:                                  currentGraphV.AddReduction(new Reduction(newVertex, prod, pos, Some edge))
                   edge.Ast
               | x -> (newVertex.Edge x).Ast
  -        addChildren nodes.[ast] (Microsoft.FSharp.Collections.Array.copy path) prod
  +        if ast >= 0 
  +        then addChildren nodes.[ast] 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, _nonTerm, _pos, _startV) -> 
  -                                    prod = _prod && remainLength = _remainLength && path = _path && nonTerm = _nonTerm && pos = _pos && startV = _startV)
  +                       (fun (_prod, _remainLength, _path : Path, _nonTerm, _pos, _startV) -> 
  +                                    prod = _prod 
  +                                 && remainLength = _remainLength 
  +                                 && path.IsEqual(_path)
  +                                 && nonTerm = _nonTerm 
  +                                 && pos = _pos 
  +                                 && startV = _startV)
                          vertex.PassingReductions)
  -            then vertex.PassingReductions.Add (prod, remainLength, Array.copy path, nonTerm, pos, startV)
  +            then vertex.PassingReductions.Add (prod, remainLength, path, nonTerm, pos, startV)
               vertex.OutEdges |> ResizeArray.iter
                   (fun e ->
  -                    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 newPath = path.AddEdge(if e.Ast < 0 then new Epsilon(e.Ast) :> AstNode else nodes.[e.Ast])
  +                    walk (remainLength - 1) e.Dest newPath currentGraphV startV nonTerm pos prod shouldEnqueueVertex)
   
       let makeSingleReduction currentGraphV (reduction : Reduction) =
           let nonTerm = parserSource.LeftSide.[reduction.prod]
  
positive.code:                 let edge = new Edge(reduction.gssVertex, -parserSource.LeftSide.[reduction.prod]-1)
                  newVertex.addEdge edge
          else 
              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<_>) =
  
negative.code: 
              let arr = parserSource.ZeroReduces.[state].[parserSource.TokenToNumber e.Tag]
              if arr <> null then
                  //verticesToProcess.Enqueue currentGraphV
                  customEnqueue currentGraphV
                  for prod in arr do
                      reductions.Add(new Reduction(gssVertex, prod, 0, None), currentGraphV)
          
  