anchor.diff:  let num_10 = Int 10
   
   let pow2 (n:int) = 
  -    if n < 0 
  -        then 
  -            let n' = System.Math.Abs(n)
  -            (Int 1) / (power_num num_2 (Int n'))
  -        else power_num num_2 (Int n)
  -
  -let pow10 (n:int) = 
  -    if n < 0 
  -        then 
  -            let n' = System.Math.Abs(n)
  -            (Int 1) / (power_num num_10 (Int n'))
  -        else power_num num_10 (Int n)
  +    if n < 0 then
  +        let n' = System.Math.Abs(n)
  +        (Int 1) / (power_num num_2 (Int n'))
  +    else power_num num_2 (Int n)
  +
  +let pow10 (n:int) =
  +    if n < 0 then 
  +        let n' = System.Math.Abs(n)
  +        (Int 1) / (power_num num_10 (Int n'))
  +    else power_num num_10 (Int n)
   
   /// Returns numerator and denominator of normalized fraction.
   let numdom r =
  
positive.code:     | [] -> failwith "last"
  
  /// Computes the sub-list of a list consisting of all but the last element.
  // OPTIMIZE : Make this an alias for List.dropLast.
  let rec butlast l = 
      match l with
      | [_] -> []
  
negative.code: (* ------------------------------------------------------------------------- *)
  
  /// Concatenates a list of strings into one string.
  let implode (l : string list) : string =
      // Preconditions
      checkNonNull "l" l
  
      // Pattern-match on the list to provide optimized implementations
      // for lists with just a few elements.
      match l with
      | [] -> ""
      | [x] -> x
      | x :: [y] ->
          System.String.Concat (x, y)
      | x :: y :: [z] ->
          System.String.Concat (x, y, z)
      | w :: x :: y :: [z] ->
          System.String.Concat (w, x, y, z)
      | _ ->
          // TODO : If it's not much slower, just use System.String.Join here instead to simplify things.
          // System.String.Join ("", l)
          let sb = System.Text.StringBuilder ()
          let rec implode = function
              | [] ->
                  sb.ToString ()
              | (hd : string) :: tl ->
                  Debug.Assert (not <| isNull hd,
                      "The string list contains at least one element which is a null string.")
                  sb.Append hd |> ignore
                  implode tl
          implode l
  
  /// Converts a string into a list of single-character strings.
  let explode (s : string) : string list =
      // Preconditions
      checkNonNull "s" s
  
      let rec exap n l = 
          if n < 0 then l
          else exap (n - 1) ((s.[n].ToString()) :: l)
      exap (String.length s - 1) []
  
  (* ------------------------------------------------------------------------- *)
  