anchor.diff:          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)
  +                let l = addNode <| new AST (Unchecked.defaultof<_>, null)
  +                let edge = new Edge(final, l-1)                
  +                addEdge customEnqueue 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 = 
  +        else
  +            let l = addNode <| new AST (Unchecked.defaultof<_>, null) 
  +            let edge = new Edge(final, l-1)            
  +            addEdge customEnqueue startV isNew newVertex edge (pos > 0)
  +            addChildren nodes.[l - 1] path prod
  +
  +    let rec walk customEnqueue remainLength (vertex : Vertex) path startV nonTerm pos prod shouldEnqueueVertex = 
           if remainLength = 0 
  -        then handlePath path vertex startV nonTerm pos prod shouldEnqueueVertex
  +        then handlePath customEnqueue path vertex startV nonTerm pos prod shouldEnqueueVertex
           else
               if not (ResizeArray.exists 
                          (fun (_prod, _remainLength, _path : Path, _nonTerm, _pos, _startV) ->
  
positive.code:             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
          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<_>) =
          while currentGraphV.reductions.Count > 0 do
              let r = currentGraphV.GetReduction()
              makeSingleReduction currentGraphV r
  
  
      let handlePassingReductions (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
              graphV.passingReductions.Remove((v, e)) |> ignore
  
      let processVertex v = 
          makeReductions v
  
          let newGssVs = new ResizeArray<_>(2)
          for gssVertex in v.unprocessedGssVertices do 
              newGssVs.AddRange(push v gssVertex)
          v.unprocessedGssVertices.Clear()
          if newGssVs.Count > 0 
          then
  
negative.code: 
          if v.passingReductions.Count > 0
          then
              handlePassingReductions customEnqueue v
      let main () =
          let threads = 7
          let verticesToProcess = [| for i in 0..threads -> new Queue<VInfo<_>>()|]
          let customEnqueue (verticesToProcess:Queue<VInfo<_>>) (elem : VInfo<_>) =
              if verticesToProcess.Count = 0 || ((verticesToProcess.ElementAt (verticesToProcess.Count - 1)).vNum = elem.vNum |> not)
              then verticesToProcess.Enqueue(elem)
  
          innerGraph.Vertices
          |> Seq.iteri (fun i v -> 
              let _,_ = addVertex v startState v.unprocessedGssVertices
              verticesToProcess.[i / (innerGraph.VertexCount / threads)].Enqueue (v))
  
          let _do (verticesToProcess:Queue<_>) =
              while !errorIndex = -1 && verticesToProcess.Count > 0 do
                  let curV = verticesToProcess.Dequeue()
                  processVertex (customEnqueue verticesToProcess) curV
  
          verticesToProcess |> Array.Parallel.iter _do
  
      if tokens.EdgeCount = 0
      then
  