anchor.diff:                  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]
  +            let path = new Path(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<_>) =
  
positive.code:                 let children = new Family(parserSource.StartRule, new Nodes([|res|]))
                  new AST(children, null)
              for v in innerGraph.Edges |> Seq.filter (fun e -> e.Target = finalV) |> Seq.collect (fun e -> e.Source.processedGssVertices) do
                  if parserSource.AccStates.[v.State] then
                      root := Some nodes.Count
                      nodes.[(v.Edge 0).Ast]
                      |> addTreeTop
                      |> nodes.Add
              match !root with
  
negative.code:     val edge : Edge option
      new (_gssVertex, _prod, _pos, _edge) = {gssVertex = _gssVertex; prod = _prod; pos = _pos; edge = _edge}
  
  and [<AllowNullLiteral>]
      Path (head : AstNode, tail : Path, length : int) = 
      member this.Head = head
      member this.Tail = tail
      member this.Length = length
      
      member this.AddEdge edge =
          new Path(edge, this, this.Length + 1)
      
      member this.IsEqual (other : Path) =
          this = null && other = null || this.Head = other.Head && this.Tail = other.Tail
  
      member this.IsEqual (nodes : Nodes) = 
          nodes.Length = this.Length 
          && let h = ref this in nodes.isForAll(fun x -> let res = x = h.Value.Head
                                                         h := h.Value.Tail
                                                         res )
  
      member this.ToArray() =
          let p = ref this
          Array.init this.Length (fun _ -> let cur = p.Value.Head
                                           p := p.Value.Tail
                                           cur)
         
      new (head, tail) = new Path(head, tail, if tail = null then 1 else tail.Length + 1)
      new (edge) = new Path (edge, null, 1)
  
  let buildAstAbstract<'TokenType> (parserSource : ParserSource<'TokenType>) (tokens : ParserInputGraph<'TokenType>) =
      let statesCount = parserSource.Gotos.Length
  