anchor.diff:  
       /// Calculates a new best cell based on the three previous adjacent cells, the current sequence characters, and the costs.
       [<ReflectedDefinition>]
  -    let private bestTrace (m:Cell) (x:Cell) (y:Cell) (seq1Char:int) (seq2Char:int) (costs:Costs) (local:bool) =
  +    let private bestTrace (m:Cell) (x:Cell) (y:Cell) (seq1Char:int) (seq2Char:int) (costs:Costs) (negativeScoring:int->int) =
           let diagonalCost (cell:Cell) =
               let sim' = costs.ScoringMatrix.[seq1Char - 42].[seq2Char - 42]
               let mM = cell.M.Value + sim' 
               let mY = cell.Y.Value + sim' 
               let mX = cell.X.Value + sim'
  -            if local then
  -                max mM mY |> max mX |> max 0
  -            else 
  -                max mX mY |> max mM 
  +            max mX mY |> max mM |> negativeScoring 
   
           let horizontalCost (cell:Cell) = 
               let xM = cell.M.Value + costs.Open
               let xX = cell.X.Value + costs.Continuation
  -            if local then
  -                max xM xX |> max 0
  -            else
  -                max xX xM
  +            max xX xM |> negativeScoring
   
           let verticalCost (cell:Cell) =
               let yM = cell.M.Value + costs.Open
               let yY = cell.Y.Value + costs.Continuation
  -            if local then
  -                max yM yY |> max 0
  -            else
  -                max yY yM
  +            max yY yM |> negativeScoring
   
           let mCost = diagonalCost m
           let xCost = horizontalCost x
  
positive.code:                 matrix
  
              // Generate cell matrix
              let matrix = createCellMatrix initFirstRowCol costs fstSeq sndSeq false
  
              // Get alignment from cell matrix
              let i, j = Array2D.length1 matrix - 1, Array2D.length2 matrix - 1
  
negative.code:             let sndSeq = sndSeq |> BioArray.toString |> Conversion.stringToInts
  
              // Generate cell matrix
              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
  