anchor.diff:                  i <- 0
                   count <- -1
                   while i < edges.Count do
  -                    let (v, s, _,a) = edges.[i]
  +                    let (v,_,a) = edges.[i]
                       let mutable j = i+1
  -                    while j < edges.Count && frth edges.[j] = a do
  +                    while j < edges.Count && trd edges.[j] = a do
                           j <- j + 1
                       let other = 
                           if j <> i + 1 then
                               let res = Array.zeroCreate (j - i - 1)
                               for k = i + 1 to j-1 do
  -                                res.[k-i-1] <- trd4 edges.[k]
  +                                res.[k-i-1] <- snd3 edges.[k]
                               res
                           else
                               null
                       if count >= 0 then
  -                        vEdges.[count] <- new Edge(v, s, box a)
  +                        vEdges.[count] <- new Edge(v, box a)
                       else
  -                        first <- new Edge(v, s, box a)
  +                        first <- new Edge(v, box a)
                       count <- count + 1
  -                    a.first <- trd4 edges.[i]
  +                    a.first <- snd3 edges.[i]
                       a.other <- other
                       i <- j
   
                   for i = 0 to simpleEdges.[vertex].Count - 1 do
  -                    let v, s, a = simpleEdges.[vertex].[i]
  +                    let v, a = simpleEdges.[vertex].[i]
                       if count >= 0 then
  -                        vEdges.[count] <- new Edge(v, s, a)
  +                        vEdges.[count] <- new Edge(v, a)
                       else
  -                        first <- new Edge(v, s, a)
  +                        first <- new Edge(v, a)
                       count <- count + 1
   
                   stateToVertex.[vertex].OutEdges <- UsualOne<_>(first, vEdges)
  
positive.code:             v
  
          ignore <| addVertex startState 0 None
          let inline fst3 (x,_,_) = x
          let inline snd3 (_,x,_) = x
          let inline trd (_,_,x) = x
          let inline trd4 (_,_,x,_) = x
          let inline frth (_,_,_,x) = x
  
negative.code:             pushes.Clear()
              usedStates.Clear()
  
              for (vertex, state) in oldPushes do
                  let newVertex = addVertex state num <| Some (vertex, newAstNode)
                  addSimpleEdge vertex newAstNode simpleEdges.[state]
          
          /// returns all the terminals and non-terminals that make the push or reduce
          /// it's used by recovery
  