anchor.diff:  
   module Checked =
       open Checked
  -    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_Addition = invokeBinOp "op_Addition" (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (+) (Some(+)) (Some(+)) (Some(+)) (Some(+)) //dynamic impl is given in F# lib, but we implement ourselves for perf. gain
  +    let op_Multiply = invokeBinOp "op_Multiply" (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (*) (Some(*)) (Some(*)) (Some(*)) None
  +    let op_Subtraction = invokeBinOp "op_Subtraction" (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (-) (Some(-)) (Some(-)) (Some(-)) None
   
       let binOpLookup : System.Collections.Generic.IDictionary<string, (Type->Type->Type->obj->obj->obj)> = 
           dict
  
positive.code:     | m,null | null,m -> m.Invoke(null,[| x; y |])
      | _ -> raise (NotSupportedException ())
  
  ///name is the name of the unary op method, aty is the arg type, x is the arg
  let invokeUnaryOpDynamic name (aty:Type) (x:obj) =
      let ameth = aty.GetMethod(name,[| aty |])
      match ameth  with 
      | null -> raise (NotSupportedException ())
      | m -> m.Invoke(null,[| x |])
  
  ///aty is the arg type, bty is the return type, x is the arg
  let invokeExplicitOpDynamic (aty:Type) (bty:Type) (x:obj) =
      let ameth = aty.GetMethods() |> Array.find (fun m -> m.Name = "op_Explicit" && ((m.GetParameters() |> Array.map(fun p -> p.ParameterType)) = [| aty |]) && m.ReturnType = bty)
      match ameth  with 
      | null -> raise (NotSupportedException ())
      | m -> m.Invoke(null,[| x |])
  
  let inline (|InvokeBinOpStatic|_|) (op:'a->'b->'a) (aty:Type, x:obj, y:obj) =
      if aty.Equals(typeof<'a>) then Some(op (unbox<'a> x) (unbox<'b> y))
      else None
  
negative.code: module internal Swensen.Unquote.DynamicOperators
  open System
  open System.Reflection
  
  //N.B. there are 13 primitive numeric types and also bigint to consider
  
  ///aty is the arg type, bty is the return type, x is the arg
  let invokeExplicitOpDynamic (aty:Type) (bty:Type) (x:obj) =
      let ameth = aty.GetMethods() |> Array.find (fun m -> m.Name = "op_Explicit" && ((m.GetParameters() |> Array.map(fun p -> p.ParameterType)) = [| aty |]) && m.ReturnType = bty)
      match ameth  with 
      | null -> raise (NotSupportedException ())
      | m -> m.Invoke(null,[| x |])
  
  ///name is the name of the method, aty is the type of the first arg, bty is the type of the second arg,
  ///x is the first arg, y is the second arg.
  