anchor.diff:              let k = getRightExtension rightExtension
               let rule = getRule label
               let d =
  -                if packedNodes.ContainsKey(i)
  -                then
  -                    let d1 = packedNodes.[i]
  -                    if d1.ContainsKey(j)
  +                let contains, d1 = packedNodes.TryGetValue i
  +                if contains
  +                then
  +                    let contains, d2 = d1.TryGetValue j
  +                    if contains
                       then
  -                        let d2 = d1.[j]
  -                        if d2.ContainsKey(k)
  +                        let contains, d3 = d2.TryGetValue k
  +                        if contains
                           then
  -                            d2.[k]
  +                            d3
                           else
                               let d3 = new Dictionary<int<labelMeasure>, int<nodeMeasure>>()
                               d2.Add(k, d3)
  
positive.code:             else true
                        
  
          let addContext index (label : int<labelMeasure>) vertex ast =
              if not <| containsContext index label vertex ast
              then
                  setR.Enqueue(new Context(index, label, vertex, ast))
  
          let slotIsEnd (label : int<labelMeasure>) =
              (getPosition label) = Array.length (parser.rules.[getRule label])
  
          let findSppfNode label ext : int<nodeMeasure> =
  
negative.code:                     nonTerminalNodes.[nTerm] <- d
                      num
              else
                  let contains, d1 = intermidiateNodes.TryGetValue ext
                  if contains
                  then
                      let contains, d2 = d1.TryGetValue label
                      if contains
                      then
                          d2
                      else
                          let newNode = new IntermidiateNode(int label, ext)
                          sppfNodes.Add(newNode)
  