anchor.diff:                  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               
  +
  +                let from1Matrix = nt1Matrix.[fst from1.Left..(fst from1.Right - 1), 
  +                                             snd from1.Left..(snd from1.Right - 1)]
  +                let from2Matrix = nt2Matrix.[fst from2.Left..(fst from2.Right - 1),
  +                                             (snd from2.Left)..(snd from2.Right - 1 - (from1.Size - actualColCount))]
  +                
  +                let resultRows = from1.Size
  +                let resultColumns = actualColCount
  +                let vectorLength = from1.Size
  +
  +                let multiplicationResult = GPUMultiplicator.multiplicate from1Matrix.innerValue 
  +                                                                         from2Matrix.innerValue 
  +                                                                         resultRows
  +                                                                         resultColumns
  +                                                                         vectorLength
  +                ProbabilityMatrix.create multiplicationResult resultRows resultColumns
  +                |> addProbsToPSubMatrix task.where nts 
  +//                else addProbsToPSubMatrix nts (simpleMultiplicator.multiplicate nt1Matrix nt2Matrix task.from1 task.from2 actualColCount) task.where               
                   
               crossproduct tasks nts |> Array.iter performOneTask
positive.code:             new T(Array.init (ncol * nrow) (fun x -> splitIndex x |> generator |> Probability.innerValue), nrow, ncol)
          
          let empty n = init n n (fun cell -> Probability.zero)
      
  
      type GPUMatriceswMultiplicator () =
      
          let localWorkSize = 2
          let platformName = "*"
  
negative.code:             | ex -> failwith ex.Message
  
          let mutable commandQueue = new CommandQueue(provider, provider.Devices |> Seq.head)
  
          let multiplicateProbabilities = probabilityMultQuote
          let summProbabilities = probabilitySummQuote
  
          let command = 
              <@
  