anchor.diff:  
       let verticesToRecalc = new ResizeArray<_> (10)
   
  -    let (*inline*) addChildren node (path : Path) prod =
  +    let inline comparePaths (p1:list<_>) (p2:Nodes) =
  +        let compare (x : AstNode) (y : AstNode) = 
  +            match x with
  +            | :? Epsilon as x' -> match y with | :? Epsilon as y' -> x'.EpsilonNonTerm = y'.EpsilonNonTerm | _ -> false
  +            | :? Terminal as x' -> match y with | :? Terminal as y' -> x'.TokenNumber = y'.TokenNumber | _ -> false
  +            | :? AST as xast -> match y with | :? AST as yast -> 
  +                                                    xast.pos = yast.pos 
  +                                                    && xast = yast 
  +                                             | _ -> false
  +            | _ -> false
  +        p1.Length = p2.Length
  +        && let h = ref p1 in p2.isForAll(fun x -> let res = compare x h.Value.Head
  +                                                  h := h.Value.Tail
  +                                                  res )
  +
  +    let inline addChildren node path prod =
           let ast = getFamily node
           let familyOpt = 
  -            ast.findFamily (function family -> family.prod = prod && path.IsEqual(family.nodes))
  +            ast.findFamily (function family -> family.prod = prod && (comparePaths path family.nodes))
           match familyOpt with 
           | None -> 
  -            let newFamily = new Family (prod, new Nodes(path.ToArray()))
  +            let newFamily = new Family (prod, new Nodes(path |> List.toArray))
               if ast.first = Unchecked.defaultof<_> 
               then ast.first <- newFamily 
               else
  
positive.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) = 
  
      let compare (x : AstNode) (y : AstNode) = 
          match x with
          | :? Epsilon as x' -> match y with | :? Epsilon as y' -> x'.EpsilonNonTerm = y'.EpsilonNonTerm | _ -> false
          | :? Terminal as x' -> match y with | :? Terminal as y' -> x'.TokenNumber = y'.TokenNumber | _ -> false
          | :? AST as xast -> match y with | :? AST as yast -> 
                                                  xast.pos = yast.pos 
                                                  && xast = yast 
                                           | _ -> false
          | _ -> false
  
      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) =
          if this = null && other <> null || this <> null && other = null
          then false
          else 
              this = null && other = null || compare this.Head other.Head && this.Tail.IsEqual(other.Tail)
  
      member this.IsEqual (nodes : Nodes) = 
          nodes.Length = this.Length 
          && let h = ref this in nodes.isForAll(fun x -> let res = compare 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 startV, finalV, innerGraph =
          let verticesMap = Array.zeroCreate (Seq.max tokens.Vertices + 1)            
          for i in tokens.Vertices do
  
negative.code:         let copyPR = ResizeArray.copy(graphV.passingReductions)
          for (v, e) in copyPR do
              let passingReductions = v.PassingReductions
              for p in passingReductions do
                  let newPath = (if e.Ast < 0 then new Epsilon(e.Ast) :> AstNode else nodes.[e.Ast])::p.path
                  walk (p.remainLength - 1) e.Dest newPath startV p.nonTerm p.pos p.prod true
              graphV.passingReductions.Remove((v, e)) |> ignore
  
      let processVertex v = 
  