anchor.diff:                      else checkIndex start index tryFind ruleCheck
                   | None -> checkIndex start index tryFind ruleCheck
   
  -            let startLeft = ( leftI * rowSize + leftL - calcDiff leftI ) * nTermsCount
  +            let startLeft = ( leftL * rowSize + leftI - calcDiff leftL ) * nTermsCount // ( leftI * rowSize + leftL - calcDiff leftI ) * nTermsCount
               let left = tryFind startLeft startLeft rule.R1
   
  -            let startRight = ( rightI * rowSize + rightL - calcDiff rightI ) * nTermsCount
  +            let startRight = ( rightL * rowSize + rightI - calcDiff rightL ) * nTermsCount // ( rightI * rowSize + rightL - calcDiff rightI ) * nTermsCount
               let right = tryFind startRight startRight rule.R2
                   
               match right with
  
positive.code:         let processRule rule ruleIndex i k l =
              let rule = getRuleStruct rule
              if rule.R2 <> 0us then
                  let leftStart = ( i * rowSize + k - calcDiff i ) * nTermsCount
                  let rightStart = ( (k+i+1) * rowSize + l-k-1 - (calcDiff (k+i+1)) ) * nTermsCount
  
                  for m in 0..nTermsCount - 1 do
                      let leftCell = recTable.[leftStart + m]
  
negative.code:                                 let lblWithState = chooseNewLabel rule.Label cellData1.Label cellData2.Label cellData1.LabelState cellData2.LabelState
                                  let newWeight = weightCalcFun rule.Weight cellData1.Weight cellData2.Weight
                                  let currentElem = buildData ruleIndex lblWithState.State lblWithState.Label newWeight
                                  recTable.[
                                      ( l * rowSize + i - calcDiff l ) * nTermsCount + int rule.RuleName - 1
                                      // ( i * rowSize + l - calcDiff i ) * nTermsCount + int rule.RuleName - 1
                                      ] <- new CellData(currentElem, uint32 k) |> Some
              //printfn "(%d, %d, %d) -> (%d, %d) -> %d + <rule>" i k l i l ((l * rowSize + i - calcDiff l ) * nTermsCount)
  
          let elem i len rulesIndexed = 
              // foreach rule r in grammar in parallel
              rulesIndexed 
  