anchor.diff:              let sndSeq = sndSeq |> BioArray.toString |> Conversion.stringToInts
   
               // Generate cell matrix
  -            let matrix = createCellMatrix id costs fstSeq sndSeq true
  +            let matrix = createCellMatrix id costs fstSeq sndSeq <@ fun x -> max x 0 @>
   
               // Get alignment from cell matrix
               let i, j = Array2D.indexMaxBy (fun (c:Cell) -> c.M.Value) matrix
  
positive.code:         let initialJ = if d < maxRow then 0 else d - maxRow
          initialJ + m
  
      let private kernel (matrix:Cell[,]) (costs:Costs) (fstSeq:int[]) (sndSeq:int[]) (mMaxs:int[]) (local:bool)  = 
          let start = blockIdx.x * blockDim.x + threadIdx.x
          let stride = gridDim.x * blockDim.x
  
          let rows = matrix.GetLength(0)
          let cols = matrix.GetLength(1)
  
          for d in 0..(rows + cols) do
              let mMax = mMaxs.[d]
              let mutable m = start
              while m <= mMax do
                  let i = getI d m (rows - 1)
                  let j = getJ d m (rows - 1)
  
                  // Avoid the first row and first column of the matrix because they are reserved for the sequences in the form of 0s.
                  if i <> 0 && j <> 0 then
                      matrix.[i,j] <- bestTrace matrix.[i-1,j-1] matrix.[i,j-1] matrix.[i-1,j] fstSeq.[i-1] sndSeq.[j-1] costs local
                  m <- m + stride
              __syncthreads()
  
      let createCellMatrix (initMatrix:Cell[,] -> Cell[,]) (costs:Costs) (fstSeq:int[]) (sndSeq:int[]) (local:bool) =
          let rows, cols = fstSeq.Length + 1, sndSeq.Length + 1
          let dMax = rows + cols - 1
          let dMaxs = [|for d in 0..dMax -> d|]
  
negative.code:         let matrixGpu = gpu.Allocate<Cell>(matrix)
  
          let lp = LaunchParam(1, 512)
          gpu.Launch (kernel negativeScoring |> Compiler.makeKernel) lp matrixGpu costs fstSeqGpu sndSeqGpu mMaxsGpu
  
          let matrix = Gpu.CopyToHost(matrixGpu)
          Gpu.Free(fstSeqGpu)
  