anchor.diff:                  -d + 2 * l - 2 - b
   
           [<ReflectedDefinition>]
  -        let initial_i d max_row = 
  -            if d > max_row then max_row else d
  -
  -        [<ReflectedDefinition>]
  -        let initial_j d max_row =
  -            if d < max_row then 0 else d - max_row
  -
  -        [<ReflectedDefinition>]
  -        let get_i d m max_row = 
  -            (initial_i d max_row) - m
  -
  -        [<ReflectedDefinition>]
  -        let get_j d m max_row = 
  -            (initial_j d max_row) + m
  -
  -        [<ReflectedDefinition>]
  -        let kernel (matrix:(prim_cell)[,]) (fst_seq:int[]) (snd_seq:int[]) (m_maxs:int[]) =
  +        let initialI d maxRow = 
  +            if d > maxRow then maxRow else d
  +
  +        [<ReflectedDefinition>]
  +        let initialJ d maxRow =
  +            if d < maxRow then 0 else d - maxRow
  +
  +        [<ReflectedDefinition>]
  +        let getI d m maxRow = 
  +            (initialI d maxRow) - m
  +
  +        [<ReflectedDefinition>]
  +        let getJ d m maxRow = 
  +            (initialJ d maxRow) + m
  +
  +        [<ReflectedDefinition>]
  +        let kernel (matrix:(Cell)[,]) (fstSeq:int[]) (sndSeq:int[]) (mMaxs:int[]) =
   
               let start = blockIdx.x * blockDim.x + threadIdx.x
               let stride = gridDim.x * blockDim.x
  
positive.code:     // Conversion functions
  
      /// Character array to integer array
      let chars_to_ints (chars:char[]) =
          Array.map (fun c -> int c) chars
  
      /// Character array to string
  
negative.code:         i_best, j_best
  
      /// Primitive version of TraceBackZerovalue. Note how I represent a gap with a "-1"
      let rec traceBackPrimitive (fstSeq:int[]) (sndSeq:int[]) (i:int) (j:int) (acc1:int list) (acc2:int list) (matrix:Cell[,]) =
          match matrix.[i,j].M.TraceType with
          |0uy -> acc1, acc2
          |1uy -> traceBackPrimitive fstSeq sndSeq (i-1) (j-1) (fstSeq.[i-1]::acc1) (sndSeq.[j-1]::acc2) matrix
          |2uy -> traceBackPrimitive fstSeq sndSeq (i)   (j-1) (-1::acc1)            (sndSeq.[j-1]::acc2) matrix
          |3uy -> traceBackPrimitive fstSeq sndSeq (i-1) (j)   (fstSeq.[i-1]::acc1) (-1::acc2)            matrix
  
  
      module ParallelMatrix =
  
          [<ReflectedDefinition>]
          let maxDiagCell (d:int) (rows:int) (cols:int) =
              let mutable l = 0
              let mutable a = 0
              if rows > cols then
  