anchor.diff:          let packedNodesY = Array.zeroCreate<int> (inputLength + 1)
           let packedNodesZ = Array.zeroCreate<int> (inputLength + 1)
           //let packedNodes = Array.zeroCreate<IntDictionary<IntDictionary<int>>> (inputLength + 1)
  -        let packedNodes = Array.zeroCreate<IntDictionary<IntDictionary<ResizableUsualOne<LblNodePair>>>> (inputLength + 1)
  -
  +        let packedNodes = new Dictionary<int, int<nodeMeasure>>()
  +         //Array.zeroCreate<IntDictionary<IntDictionary<ResizableUsualOne<LblNodePair>>>> (inputLength + 1)
  +        let inline f x y z = x * (inputLength + 1) * (inputLength + 1) + y * (inputLength + 1) + z
  +        let inline f4 x y z w = x * parser.Slots.Count * (inputLength + 1) * (inputLength + 1) + y * (inputLength + 1) * (inputLength + 1) + z * (inputLength + 1) + w
           let nonTerminalNodesReadCount = ref 0
           let nonTerminalNodesWriteCount = ref 0 
           let nonterminalNodesX = Array.zeroCreate parser.NonTermCount
           let nonterminalNodesY = Array.zeroCreate (inputLength + 1)
           let nonterminalNodesZ = Array.zeroCreate (inputLength + 1)        
  -        let nonTerminalNodes = Array.zeroCreate<IntDictionary<IntDictionary<int<nodeMeasure>>>> parser.NonTermCount
  +        let nonTerminalNodes = new Dictionary<int, int<nodeMeasure>>()
           //let nonTerminalNodes = Array3D.zeroCreate<int<nodeMeasure>> parser.NonTermCount (inputLength + 1) (inputLength + 1)
   
   
           let intermidiateNodesReadCount = ref 0
           let intermidiateNodesWriteCount = ref 0
           //we can use dictionary <extension, dict>
  -        let intermidiateNodes = Array2D.zeroCreate<ResizableUsualFive<LblNodePair>> (inputLength + 1) (inputLength + 1) 
  +        let intermidiateNodes = new Dictionary<int, int<nodeMeasure>>()
    
    //посчитать размерв коллекций
           let edgesReadCount = ref 0
  
positive.code:             let i = getLeftExtension leftExtension
              let j = getRightExtension leftExtension
              let k = getRightExtension rightExtension
              //Array.zeroCreate<IntDictionary<IntDictionary<int>>> (inputLength + 1)            
              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 ResizableUsualOne<_>(new LblNodePair(label,newNode))
                          d2.Add(k, d3)
                          newNode
                  else
                      let d2 = new IntDictionary<ResizableUsualOne<_>>()
                      let newNode = createNode()
                      let d3 = new ResizableUsualOne<_>(new LblNodePair(label,newNode))
                      d2.Add(k, d3)
                      d1.Add(j, d2)
                      newNode
              else
                  let d1 = new IntDictionary<IntDictionary<ResizableUsualOne<_>>>()
                  let d2 = new IntDictionary<ResizableUsualOne<_>>()
                  let newNode = createNode()
                  let d3 = new ResizableUsualOne<_>(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> =
  
negative.code:         let findSppfNode label ext : int<nodeMeasure> =
              let isEnd = slotIsEnd label
              let nTerm = parser.LeftSide.[getRule label]
              let lExt = getLeftExtension ext
              let rExt = getRightExtension ext
              if isEnd
              then
                  let key = f lExt rExt nTerm
                  let contains, n = nonTerminalNodes.TryGetValue(key)
                  if not contains
                  then
                      let newNode = new NonTerminalNode(nTerm, ext)
                      sppfNodes.Add(newNode)
                      let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                      nonTerminalNodes.Add(key, num)
                      num
                  else n
              else  
                  let key = f lExt rExt (int label)
                  let contains, n = intermidiateNodes.TryGetValue key
                  if not contains
                  then
                      let newNode = new IntermidiateNode(int label, ext)
                      sppfNodes.Add(newNode)
                      let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                      intermidiateNodes.Add(key, num)
                      num  
                  else n
  
          let findSppfPackedNode symbolNode label leftExtension rightExtension (left : INode) (right : INode) : int<nodeMeasure> = 
              let rule = getRule label
  