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:         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 = 
  
negative.code:     val edge : Edge option
      new (_gssVertex, _prod, _pos, _edge) = {gssVertex = _gssVertex; prod = _prod; pos = _pos; edge = _edge}
  
  
  and [<Struct>]
      Reduction2<'TokenType> =    
      val prod : int
      val remainLength: int
      val path : list<AstNode>
      val nonTerm: int
      val pos : int    
      new (_prod, _remainLength, _path, _nonTerm, _pos) = {prod = _prod; remainLength = _remainLength; path = _path; nonTerm = _nonTerm; pos = _pos}
      
  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
  