anchor.diff:                          term.Extension 
                       | _ -> failwith "Smth strange, Nastya" 
                       
  -                let y = findSppfNode label (getLeftExtension leftExt) (getRightExtension rightExt)
  +                let y = findSppfNode label (packExtension (getLeftExtension leftExt) (getRightExtension rightExt))
                   ignore <| findSppfPackedNode y label leftExt rightExt currentLeft currentRight
                   y
               else
  -                let y = findSppfNode label (getLeftExtension rightExt) (getRightExtension rightExt)
  +                let y = findSppfNode label (packExtension (getLeftExtension rightExt) (getRightExtension rightExt))
                   ignore <| findSppfPackedNode y label rightExt rightExt dummyAST currentRight 
                   y
               
  
positive.code:                 let cur = nonTerminalNodes.[nTerm]
                  if  cur <> Unchecked.defaultof<_> //<Dictionary<int64<extension>, int<nodeMeasure>>>
                  then
                          let contains , d1 = cur.TryGetValue(lExt)
                          if contains
                          then
                              let contains, d2 = d1.TryGetValue(rExt)
                              if contains
                              then
                                  d2
                              else
                                  let newNode = new NonTerminalNode(nTerm, packExtension lExt rExt)
                                  sppfNodes.Add(newNode)
                                  let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                                  d1.Add(rExt, num)
                                  num
                          else
                              let d2 = new Dictionary<int, int<nodeMeasure>>()
                              //let d1 = new Dictionary<int, Dictionary<int, int<nodeMeasure>>>()
                              let newNode = new NonTerminalNode(nTerm, packExtension lExt rExt)
                              sppfNodes.Add(newNode)
                              let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                              d2.Add(rExt, num)
                              cur.Add(lExt, d2)
                              num
                          
                  else
                      //let d = new Dictionary<int64<extension>, int<nodeMeasure>>()
                      let d2 = new Dictionary<int, int<nodeMeasure>>()
                      let d1 = new Dictionary<int, Dictionary<int, int<nodeMeasure>>>()
                      let newNode = new NonTerminalNode(nTerm, packExtension lExt rExt)
                      sppfNodes.Add(newNode)
                      let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                      //d.Add(ext, num)
                      d2.Add(rExt, num)
                      d1.Add(lExt, d2)
                       
                      nonTerminalNodes.[nTerm] <- d1 
                      num
              else
                  let contains, d1 = intermidiateNodes.TryGetValue lExt
                  if contains
                  then
                      let contains, d2 = d1.TryGetValue rExt
                      if contains
                      then
                          let contains, d3 = d2.TryGetValue(label)
                          if contains
                          then
                              d3
                          else
                              let newNode = new IntermidiateNode(int label, packExtension lExt rExt)
                              sppfNodes.Add(newNode)
                              let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                              d2.Add(label, num)
                              num
  
                      else
                          let d2 = new Dictionary<int<labelMeasure>, int<nodeMeasure>>()
                          let newNode = new IntermidiateNode(int label, packExtension lExt rExt)
                          sppfNodes.Add(newNode)
                          let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                          d2.Add(label, num)
                          d1.Add(rExt,d2)
                          num  
                  else
                      let d1 = new Dictionary<int, Dictionary<int<labelMeasure>, int<nodeMeasure>>>()
                      let d2 = new Dictionary<int<labelMeasure>, int<nodeMeasure>>()
                      let newNode = new IntermidiateNode(int label, packExtension lExt rExt)
                      sppfNodes.Add(newNode)
                      let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                      d2.Add(label, num)
                      d1.Add(rExt, d2)
                      intermidiateNodes.Add(lExt, d1)
                      num
  
          let findSppfPackedNode symbolNode label leftExtension rightExtension (left : INode) (right : INode) : int<nodeMeasure> = 
  
negative.code:             let i = getLeftExtension leftExtension
              let j = getRightExtension leftExtension
              let k = getRightExtension rightExtension
                          
              let d1 = packedNodes.[i]
              if d1 <> Unchecked.defaultof<_>
              then
                  let contains, d2 = d1.TryGetValue j
                  if contains
                  then
                      let contains, d3 = d2.TryGetValue k
                      if contains
                      then                            
                          match d3.TryFind (fun x -> x.lbl = label) with
                          | Some num -> num.node
                          | None -> 
                              let newNode = createNode()
                              d3.Add(new LblNodePair(label,newNode))
                              newNode
                      else
                          let newNode = createNode()
                          let d3 = new ResizibleUsualOne<_>(new LblNodePair(label,newNode))
                          d2.Add(k, d3)
                          newNode
                  else
                      let d2 = new Dictionary<int, ResizibleUsualOne<_>>()
                      let newNode = createNode()
                      let d3 = new ResizibleUsualOne<_>(new LblNodePair(label,newNode))
                      d2.Add(k, d3)
                      d1.Add(j, d2)
                      newNode
              else
                  let d1 = new Dictionary<int, Dictionary<int, ResizibleUsualOne<_>>>()
                  let d2 = new Dictionary<int, ResizibleUsualOne<_>>()
                  let newNode = createNode()
                  let d3 = new ResizibleUsualOne<_>(new LblNodePair(label,newNode))
                  d2.Add(k, d3)
                  d1.Add(j, d2)
                  packedNodes.[i] <- d1
                  newNode
                  
          let getNodeP (label : int<labelMeasure>) (left : int<nodeMeasure>) (right : int<nodeMeasure>) : int<nodeMeasure> =
              let currentRight = sppfNodes.Item (int right)
  