anchor.diff:              target.reductions.Enqueue(r)
           
           currentGraphV.processedGssVertices.Add(gssVertex)
  +        newUnprocessedGssVs
   
       let (*inline*) addVertex (currentGraphV:VInfo<_>) state (edgeOpt : option<Edge>) =
           let mutable v = null
  
positive.code: 
      let processVertex v = 
          makeReductions v
          for gssVertex in v.unprocessedGssVertices do push v gssVertex gssVertex.State
          v.unprocessedGssVertices.RemoveAll(fun _ -> true) |> ignore
          if verticesSeenBefore.[v]
          then
              for e in innerGraph.OutEdges(v) do
  
negative.code:     let verticesSeenBefore = new Dictionary<_,_>()
      for v in innerGraph.Vertices do
          verticesSeenBefore.Add(v, false)
      
      let edgesToTerms = new Dictionary<_,_>()
      let push currentGraphV gssVertex state =
          let reductions = new ResizeArray<_>(10)
          let newUnprocessedGssVs = new ResizeArray<_>(2)
          for e in innerGraph.OutEdges currentGraphV do
          //printfn "v(%d,%d)" state num
              let push = parserSource.Gotos.[state].[parserSource.TokenToNumber e.Tag]
              if push <> 0 
              then
                  let findGssVertex (target : VInfo<_>) = 
                      let srcV = target.processedGssVertices |> ResizeArray.tryFind(fun v -> v.State = push)
                      match srcV with
                      | Some v -> v
                      | None -> 
                          let srcV = target.unprocessedGssVertices |> ResizeArray.tryFind(fun v -> v.State = push)
                          match srcV with
                          | Some v -> v
                          | None -> 
                              let v = new Vertex(push, target.vNum)
                              if currentGraphV = target
                              then newUnprocessedGssVs.Add v
                              else target.unprocessedGssVertices.Add v
                              v
                  let targetGssV = findGssVertex e.Target
  
                  let mutable edge = Unchecked.defaultof<_>
                  if edgesToTerms.ContainsKey e
                  then
                      edge <- new Edge(gssVertex, edgesToTerms.[e])
                      targetGssV.addEdge edge
                  else 
                      nodes.Add <| Term e.Tag
                      edgesToTerms.Add(e, nodes.Count - 1)
                      edge <- new Edge(gssVertex, nodes.Count - 1)
                      targetGssV.addEdge edge
  
                  for e2 in innerGraph.OutEdges e.Target do
                      let arr = parserSource.Reduces.[push].[parserSource.TokenToNumber e2.Tag]
                      if arr <> null then
                          for (prod, pos) in arr do
                              //printf "%A %A %d %d\n" v.label v.outEdges prod pos
                              reductions.Add(gssVertex, prod, pos, Some edge, e.Target)
  
              let arr = parserSource.ZeroReduces.[state].[parserSource.TokenToNumber e.Tag]
              if arr <> null then
  