anchor.diff:  
   module Checked =
       open Checked
  -    let op_Addition = invokeNumericBinOp "op_Addition" (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (Some(+))
  -    let op_Multiply = invokeNumericBinOp "op_Multiply" (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) None
  -    let op_Subtraction = invokeNumericBinOp "op_Subtraction" (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) None
  +    let op_Addition = invokeNumericBinOp "op_Addition" (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (Some(+)) (Some(+)) (Some(+)) (Some(+)) //dynamic impl is given in F# lib, but we implement ourselves for perf. gain
  +    let op_Multiply = invokeNumericBinOp "op_Multiply" (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (Some(*)) (Some(*)) (Some(*)) None
  +    let op_Subtraction = invokeNumericBinOp "op_Subtraction" (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (Some(-)) (Some(-)) (Some(-)) None
   
       let binOpLookup : System.Collections.Generic.IDictionary<string, (Type->Type->Type->obj->obj->obj)> = 
           dict
  
positive.code:     | null -> raise (NotSupportedException ())
      | m -> m.Invoke(null,[| x |])
  
  let inline (|InvokeBinOpStatic|_|) (op:'a->'a->'a) (aty:Type, x:obj, y:obj) =
      if aty.Equals(typeof<'a>) then Some(op (unbox<'a> x) (unbox<'a> y))
      else None
  
  let inline invokeNumericBinOp 
      name 
      op1 op2 op3 op4 op5 op6 op7 op8 op9 op10 op11 op12 op13 op14
      (op_string:(string -> string -> string) option) //for string "addition"
      (aty:Type) (bty:Type) (cty:Type) (x:obj) (y:obj) : obj =
      let dyn() = invokeBinOpDynamic name aty bty x y
      if aty.Equals(bty) && bty.Equals(cty) then
  
negative.code:         | InvokeBinOpStatic op8 (r:uint32) -> box r
          | InvokeBinOpStatic op9 (r:uint64) -> box r
          | InvokeBinOpStatic op10 (r:unativeint) -> box r
          | InvokeBinOpStatic op11 (r:bigint) -> box r
          | InvokeOptionalBinOpStatic op12 (r:float) -> box r
          | InvokeOptionalBinOpStatic op13 (r:float32) -> box r
          | InvokeOptionalBinOpStatic op14 (r:decimal) -> box r
          | InvokeOptionalBinOpStatic op15 (r:string) -> box r
          | _ -> dyn()
      else dyn()
  
  let op_Addition = invokeNumericBinOp "op_Addition" (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (Some(+)) (Some(+)) (Some(+)) (Some(+)) //dynamic impl is given in F# lib, but we implement ourselves for perf. gain
  let op_Multiply = invokeNumericBinOp "op_Multiply" (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (Some(*)) (Some(*)) (Some(*)) None
  let op_Subtraction = invokeNumericBinOp "op_Subtraction" (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (Some(-)) (Some(-)) (Some(-)) None
  let op_Division = invokeNumericBinOp "op_Division" (/) (/) (/) (/) (/) (/) (/) (/) (/) (/) (/) (Some(/)) (Some(/)) (Some(/)) None
  let op_Modulus = invokeNumericBinOp "op_Modulus" (%) (%) (%) (%) (%) (%) (%) (%) (%) (%) (%) (Some(%)) (Some(%)) (Some(%)) None
  
  let op_BitwiseOr = invokeNumericBinOp "op_BitwiseOr" (|||) (|||) (|||) (|||) (|||) (|||) (|||) (|||) (|||) (|||) (|||) None None None None
  let op_BitwiseAnd = invokeNumericBinOp "op_BitwiseAnd" (&&&) (&&&) (&&&) (&&&) (&&&) (&&&) (&&&) (&&&) (&&&) (&&&) (&&&) None None None None
  let op_ExclusiveOr = invokeNumericBinOp "op_ExclusiveOr" (^^^) (^^^) (^^^) (^^^) (^^^) (^^^) (^^^) (^^^) (^^^) (^^^) (^^^) None None None None
  let op_LeftShift = invokeNumericBinOp "op_LeftShift" (<<<) (<<<) (<<<) (<<<) (<<<) (<<<) (<<<) (<<<) (<<<) (<<<) (<<<) None None None None
  let op_RightShift = invokeNumericBinOp "op_RightShift" (>>>) (>>>) (>>>) (>>>) (>>>) (>>>) (>>>) (>>>) (>>>) (>>>) (>>>) None None None None
  
  let binOpLookup : System.Collections.Generic.IDictionary<string, (Type->Type->Type->obj->obj->obj)> = 
      dict
  