anchor.diff:              for prod in arr do
                   innerGraphV.AddReduction(new Reduction(gssVertex, prod, 0, None))
       
  -    let (*inline*) addVertex (currentGraphV:VInfo<_>) state (listToAddUnprocessedGssV : ResizeArray<_>) =
  +    let inline addVertex (currentGraphV:VInfo<_>) state (listToAddUnprocessedGssV : ResizeArray<_>) =
           let mutable v = null
           let mutable isNew = false
           let vOpt = currentGraphV.processedGssVertices |> ResizeArray.tryFind (fun v -> v.State = state)
  
positive.code:                 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<_>) =
  
negative.code: 
      let verticesToRecalc = new ResizeArray<_> (10)
  
      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 && (comparePaths path family.nodes))
          match familyOpt with 
          | None -> 
              let newFamily = new Family (prod, new Nodes(path |> List.toArray))
              if ast.first = Unchecked.defaultof<_> 
              then ast.first <- newFamily 
              else
  