anchor.diff:      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>) =
  -    let allPaths = paths
  -    let rec toList (path : Path) result = 
  -        match path with 
  -        | null -> result
  -        | _ -> toList allPaths.[path.Tail] (path.First :: result)
  -        
  -    member this.First = first
  +and [<AllowNullLiteral>]
  +    Path (head : AstNode, tail : Path, length : int) = 
  +    member this.Head = head
       member this.Tail = tail
  -    member this.AddEdge edge = 
  -        allPaths.Add this
  -        new Path (edge, allPaths.Count, allPaths)
  -    member this.ToList = toList this [] 
  +    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
  
positive.code:             |Some x -> v <- x
          |Some x -> 
              v <- x
              
              let isInUnprocessedList (v:Vertex) =
                  currentGraphV.unprocessedGssVertices 
                  |> ResizeArray.exists (fun _v -> _v.Level = v.Level && _v.State = v.State ) 
              if not <| isInUnprocessedList v 
              then
                  currentGraphV.unprocessedGssVertices.Add v 
          v, isNew
      
      let verticesToRecalc = new ResizeArray<_> (10)
  
      let (*inline*) addChildren node (path : _[]) prod =
          let ast = getFamily node
          let familyOpt = 
              ast.findFamily (function family -> family.prod = prod 
                                              && family.nodes.Length = path.Length 
                                              && 
                                                 let c = ref -1
                                                 family.nodes.isForAll(fun x -> incr c; x = path.[!c]) )
          match familyOpt with 
          | None -> 
              let newFamily = new Family (prod, new Nodes(path))
              if ast.first = Unchecked.defaultof<_> 
              then ast.first <- newFamily 
              else
  
negative.code:                 else ast.other <- Array.append ast.other [|newFamily|]
          | Some _ -> ()
  
      let handlePath (path : Path) (final : Vertex) currentGraphV startV nonTerm pos prod shouldEnqueueVertex =
          let state = parserSource.Gotos.[final.State].[nonTerm]
          let newVertex, isNew = addVertex startV state None
          if shouldEnqueueVertex && isNew then verticesToRecalc.Add startV
  