anchor.diff:              bestCost <- mCost
               bestTraceType <- 1uy
   
  -        let new_best_trace = new prim_trace_score(bestCost, bestTraceType)
  -
  -        new prim_cell(new_best_trace, x', y')
  +        let newBestTrace = new TraceScore(bestCost, bestTraceType)
  +
  +        new Cell(newBestTrace, x', y')
       
       /// Primitive function for calculating the max cell in a matrix.
  -    let index_of_max_in_matrix_TRACE (matrix:(prim_cell)[,]) =
  +    let indexOfMaxInMatrix (matrix:(Cell)[,]) =
           let mutable val_best = 0
           let mutable i_best = 0
           let mutable j_best = 0
  
positive.code:         Array.map (fun myInt -> if myInt = -1 then '-' else char myInt) ints
  
      /// String to integer array.
      let string_to_char_ints (my_string:string) =
          let exploded = explode my_string
          exploded |> chars_to_ints    
              
  
      // Alignment functions
  
      /// Primitive version of TraceScore.
      [<Struct>]
      type prim_trace_score =
          val Value : int
          val Trace_type : byte
  
          // TRACE_TYPE LEGEND:
          // 0 : NoTrace
          // 1 : Diagonal
          // 2 : Horizontal
          // 3 : Vertical
          
          [<ReflectedDefinition>]
          new (value, trace_type) = {Value = value; Trace_type = trace_type}
  
      /// Primitive version of Cell.
      [<Struct>]
      type prim_cell = 
          val M : prim_trace_score
          val X : prim_trace_score
          val Y : prim_trace_score
  
          [<ReflectedDefinition>]
          new (m, x, y) = {M = m; X = x; Y = y}
  
      /// Primitive version of AddFloatToTrace
      [<ReflectedDefinition>]
      let prim_add_float_to_trace (ts:prim_trace_score) (opc:int) =
          ts.Value + opc
  
      /// Primitive version of DiagonalCost
      [<ReflectedDefinition>]
      let diagonal_cost (cell:prim_cell) (item1:int) (item2:int) =
          let sim' = if item1 = item2 then 5 else -4
          let mM = prim_add_float_to_trace cell.M sim' 
          let mY = prim_add_float_to_trace cell.Y sim' 
          let mX = prim_add_float_to_trace cell.X sim'             
          max mM mY |> max mX |> max 0
  
      /// Primitive version of HorizontalCost
      [<ReflectedDefinition>]
      let horizontal_cost (cell:prim_cell) = 
          let xM = prim_add_float_to_trace cell.M -5
          let xX = prim_add_float_to_trace cell.X -1
          max xM xX |> max 0
  
      /// Primitive version of VerticalCost
      [<ReflectedDefinition>]
      let vertical_cost (cell:prim_cell) =
          let yM = prim_add_float_to_trace cell.M -5
          let yY = prim_add_float_to_trace cell.Y -1
          max yM yY |> max 0
  
      /// Primitive function for calculating the best cost.
      [<ReflectedDefinition>]
      let prim_best_trace m x y seq1_char seq2_char =
          let mCost = diagonal_cost m seq1_char seq2_char
  
          let xCost = horizontal_cost x
          let x' = new prim_trace_score(xCost, 2uy)
  
          let yCost = vertical_cost y
          let y' = new prim_trace_score(yCost, 3uy)
  
          let mutable bestCost = xCost
          let mutable bestTraceType = 2uy
  
negative.code:     // Conversion functions
  
      /// Character array to integer array
      let charsToInts (chars:char[]) =
          Array.map (fun c -> int c) chars
  
      /// Character array to string
  