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 findSppfNode label ext : int<nodeMeasure> =
              let isEnd = slotIsEnd label
              let nTerm = parser.LeftSide.[getRule label]
              if isEnd
              then
                  let cur = nonTerminalNodes.[nTerm]
                  if  cur <> Unchecked.defaultof<_> //<Dictionary<int64<extension>, int<nodeMeasure>>>
                  then
                          let contains , d1 = cur.TryGetValue(getLeftExtension ext)
                          if contains
                          then
                              let contains, d2 = d1.TryGetValue(getRightExtension ext)
                              if contains
                              then
                                  d2
                              else
                                  let newNode = new NonTerminalNode(nTerm, ext)
                                  sppfNodes.Add(newNode)
                                  let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                                  d1.Add(getRightExtension ext, num)
                                  num
                                  
                          else
                              let d2 = new IntDictionary<int<nodeMeasure>>()
                              //let d1 = new Dictionary<int, Dictionary<int, int<nodeMeasure>>>()
                              let newNode = new NonTerminalNode(nTerm, ext)
                              sppfNodes.Add(newNode)
                              let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                              d2.Add(getRightExtension ext, num)
                              cur.Add(getLeftExtension ext, d2)
                              num
                              
                  else
                      //let d = new Dictionary<int64<extension>, int<nodeMeasure>>()
                      let d2 = new IntDictionary<int<nodeMeasure>>()
                      let d1 = new IntDictionary<IntDictionary<int<nodeMeasure>>>()
                      let newNode = new NonTerminalNode(nTerm, ext)
                      sppfNodes.Add(newNode)
                      let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                      //d.Add(ext, num)
                      d2.Add(getRightExtension ext, num)
                      d1.Add(getLeftExtension ext, d2)
                       
                      nonTerminalNodes.[nTerm] <- d1 
                      num
              else
                  let lExt = getLeftExtension ext
                  let rExt = getRightExtension ext
                  let d1 = intermidiateNodes.[lExt, rExt]
                  if not <| d1.Eq Unchecked.defaultof<_>
                  then
                      let d2 = d1.TryFind (fun x -> x.lbl = label)
                      match d2 with
                          | Some d -> d.node 
                          | None ->
                              let newNode = new IntermidiateNode(int label, ext)
                              sppfNodes.Add(newNode)
                              let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                              addA intermidiateNodes lExt rExt (new LblNodePair(label, num))
                              num  
                  else
                      let newNode = new IntermidiateNode(int label, ext)
                      sppfNodes.Add(newNode)
                      let num = (sppfNodes.Count - 1)*1<nodeMeasure>
                      intermidiateNodes.[getLeftExtension ext, getRightExtension ext] <- new ResizableUsualFive<_>(new LblNodePair(label, num))
                      num  
                  
  
          let findSppfPackedNode symbolNode label leftExtension rightExtension (left : INode) (right : INode) : int<nodeMeasure> = 
              let rule = getRule label
  
negative.code:             let i = getLeftExtension leftExtension
              let j = getRightExtension leftExtension
              let k = getRightExtension rightExtension
              let key = f4 i j k (int label)
              //Array.zeroCreate<IntDictionary<IntDictionary<int>>> (inputLength + 1)            
              let contains, d1 = packedNodes.TryGetValue key
              if contains then d1
              else
                  let newNode = createNode()
                  packedNodes.Add(key, newNode)
                  newNode
                  
          let getNodeP (label : int<labelMeasure>) (left : int<nodeMeasure>) (right : int<nodeMeasure>) : int<nodeMeasure> =
  