anchor.diff:                      targetGssV.addEdge edge
   
                   for e2 in outEdgesInnerGraph.[e.Target.vNum] do
  -                    let arr = parserSource.ZeroReduces.[push].[parserSource.TokenToNumber e2.Tag]
  -                    if arr <> null then
  -                        for prod in arr do
  -                            reductions.Add(new Reduction(targetGssV, prod, 0, None), e.Target)
  -
  -                    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(new Reduction(gssVertex, prod, pos, Some edge), e.Target)
  -
  -            let arr = parserSource.ZeroReduces.[state].[parserSource.TokenToNumber e.Tag]
  -            if arr <> null then
  -                customEnqueue currentGraphV
  -                for prod in arr do
  -                    reductions.Add(new Reduction(gssVertex, prod, 0, None), currentGraphV)
  -        
  -        let reductionSet = new ResizeArray<Reduction * VInfo<_>>(10)
  -        for r, target in reductions do
  -            let reductionExists = 
  -                reductionSet
  -                |> ResizeArray.exists(function red, _ -> red = r)
  -            if not reductionExists then reductionSet.Add(r, target)
  -        for r, target in reductionSet do
  -            target.AddReduction(r)
  +                    addZeroReduction targetGssV push e2.Tag e.Target false
  +                    addNonZeroReduction gssVertex push e2.Tag edge e.Target
  +
  +            addZeroReduction gssVertex state e.Tag currentGraphV true
           
           if not <| currentGraphV.processedGssVertices.Contains(gssVertex)
           then 
               currentGraphV.processedGssVertices.Add(gssVertex)
           newUnprocessedGssVs
   
  -    let (*inline*) addVertex (currentGraphV:VInfo<_>) state =
  -        let mutable v = null
  -        let mutable isNew = false
  -        let vOpt = currentGraphV.processedGssVertices |> ResizeArray.tryFind (fun v -> v.State = state)
  -        match vOpt with
  -        | None ->
  -            let vOpt = currentGraphV.unprocessedGssVertices |> ResizeArray.tryFind (fun v -> v.State = state)
  -            match vOpt with
  -            | None ->
  -                v <- new Vertex(state, currentGraphV.vNum)
  -                isNew <- true
  -                currentGraphV.unprocessedGssVertices.Add v
  -            |Some x -> v <- x
  -        |Some x -> 
  -            v <- x
  -        v, isNew
  -    
       let verticesToRecalc = new ResizeArray<_> (10)
   
       let (*inline*) addChildren node (path : Path) prod =
  
positive.code:             v.unprocessedGssVertices.AddRange(newGssVs)
              customEnqueue v
  
          if verticesSeenBefore.[v.vNum] && v.passingReductions.Count > 0
          then
              handlePassingReductions v
  
          for e in (*innerGraph.OutEdges(v)*)outEdgesInnerGraph.[v.vNum] do
              if e.Target.reductions.Count > 0 || e.Target.unprocessedGssVertices.Count > 0 || e.Target.passingReductions.Count > 0
              then
                  customEnqueue e.Target
  
negative.code:                 if (pos > 0)
                  then
                      for e in outEdgesInnerGraph.[startV.vNum] do
                          addNonZeroReduction newVertex state e.Tag edge startV
                  edge.Ast
              | x -> (newVertex.Edge x).Ast 
          if ast >= 0 
  