anchor.diff:                      for slotLevels in edge.Value do
                            let slot = slotLevels.Key
                            for level in slotLevels.Value do
  -                            let tt = getLeftExtension extOnEdge
  -                            let ttt = (getRightExtension extension)
                               let ext = packExtension (getLeftExtension extOnEdge) (getRightExtension extension)
                               let newVertex = new Vertex(level, slot)
                               addContext i (u.NontermLabel*1<labelMeasure>) newVertex ext
  
positive.code:                             match curEdge with
                              | Some edge ->
                                  currentIndex := (packEdgePos curEdge.Value 0)
                                  currentIndex := packEdgePos (getEdge !currentIndex) (1 + getPosOnEdge !currentIndex)
                                  currentExtension := packExtension (getLeftExtension !currentExtension) !currentIndex
                                  currentLabel := 1<labelMeasure> * packLabelNew rule (position + 1)
                                  condition := false
                              | None _ -> ()
                      else 
                          let getIndex nTerm term = 
  
negative.code:                 if Array.length parser.rules.[rule] <> position
                  then
                      let curSymbol = parser.rules.[rule].[position]
                      let cE = CommonFuns.getEdge !currentIndex
                      let cP = CommonFuns.getPosOnEdge !currentIndex + shift
                      if parser.NumIsTerminal curSymbol || parser.NumIsLiteral curSymbol
                      then
                          
                          let chainLen = input.ChainLength.[cE]
                          if cP < chainLen - 1 
                          then    
                              let curToken = input.Edges.[cE].Tokens.[cP] 
                              if curToken = curSymbol
                              then
                                  eatTerm
                          else   
                              let curEdge = 
                                  let oEdges = outEdges.[input.Edges.[cE].End]
  