anchor.diff:              let ps = parserSource
   
               for i = 0 to ps.Gotos.[0].GetLength(0)-1 do
  -                if (ps.Gotos.[state].[i].IsSome && fst ps.Gotos.[state].[i].Value <> 0) || ps.Reduces.[state].[i] <> null
  +                if (ps.Gotos.[state].[i].IsSome && ps.Gotos.[state].[i].Value <> 0) || ps.Reduces.[state].[i] <> null
                   then expected := expected.Value.Add i
               
               !expected
  
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:                 i <- 0
                  count <- -1
                  while i < edges.Count do
                      let (v,_,a) = edges.[i]
                      let mutable j = i+1
                      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] <- snd3 edges.[k]
                              res
                          else
                              null
                      if count >= 0 then
                          vEdges.[count] <- new Edge(v, box a)
                      else
                          first <- new Edge(v, box a)
                      count <- count + 1
                      a.first <- snd3 edges.[i]
                      a.other <- other
                      i <- j
  
                  for i = 0 to simpleEdges.[vertex].Count - 1 do
                      let v, a = simpleEdges.[vertex].[i]
                      if count >= 0 then
                          vEdges.[count] <- new Edge(v, a)
                      else
                          first <- new Edge(v, a)
                      count <- count + 1
  
                  stateToVertex.[vertex].OutEdges <- UsualOne<_>(first, vEdges)
  