anchor.diff:          let addProbsToTMatrix cell nontermProbs =
               nontermProbs |> List.iter (fun (key, prob) -> tMatrix.[key].AddValueToCell cell prob)
   
  -        let addProbsToPSubMatrix nts (matrix: ProbabilityMatrix.T) (where: SubMatrix.T) =
  +        let addProbsToPSubMatrix  (where: SubMatrix.T) nts (matrix: ProbabilityMatrix.T) =
                   let whereMatrix = pMatrix.[nts]
                   let iShift = fst where.Left
                   let jShift = snd where.Left
  
positive.code:                 let nt2Matrix = tMatrix.[nt2]
                  let {where=where; from1=from1; from2=from2} = task
                  let actualColCount = (min (snd task.from2.Top) (stringSize + 1)) - snd task.from2.Left
                  if matricesSize > 64
                  then addProbsToPSubMatrix nts (GPUMultiplicator.multiplicate nt1Matrix nt2Matrix task.from1 task.from2 actualColCount) task.where
                  else addProbsToPSubMatrix nts (simpleMultiplicator.multiplicate nt1Matrix nt2Matrix task.from1 task.from2 actualColCount) task.where               
                  
              crossproduct tasks nts |> Array.iter performOneTask
negative.code:                     let tj = r.GlobalID1                    
                      let mutable buf = c.[ti * resultColumns + tj]
                      for k in 0 .. vectorLength - 1 do
                          buf <- (%summProbabilities) buf 
                                                      ((%multiplicateProbabilities) a.[ti * vectorLength + k] b.[k * resultColumns + tj])
                      c.[ti * resultColumns + tj] <- buf
              @>
  
          member this.multiplicate from1 from2 resultRows resultColumns vectorLength =
                 
              let result = Array.zeroCreate(resultRows * resultColumns)
  
              let kernel, kernelPrepare, kernelRun = provider.Compile command
      
              let d = new _2D(resultRows, resultColumns, min 4 resultRows, 1)
              kernelPrepare d resultColumns vectorLength from1 from2 result
           
              commandQueue.Add(kernelRun()).Finish() |> ignore        
              commandQueue.Add(result.ToHost provider).Finish() |> ignore
  
              result
  
          member this.releaseResources =
              commandQueue.Dispose()
              provider.Dispose()
              provider.CloseAllBuffers()
  
         
      type MatrixHolder(tKeys, pKeys, stringSize) = 
      
          let GPUMultiplicator = new GPUMatriceswMultiplicator (Probability.innerSummQuote, Probability.innerMultQuote)
  //        let simpleMultiplicator = new SimpleMatriceswMultiplicator ()
              
          // swich to dictionary (?)
          let tMatrix = Map<NonTerminal, ProbabilityMatrix.T>
  