anchor.diff:              let a : float = log2 10.0
               let a : V2d =  log2 V2d.II
               let a : ComplexD = log2 ComplexD.One
  +            let a : MyCustomNumericTypeExtensionTestTypeForInternalTesting = log2 (MyCustomNumericTypeExtensionTestTypeForInternalTesting())
               ()
               
           let cbrtWorking() =
               let a : float = cbrt 10.0
               let a : V2d =  cbrt V2d.II
               let a : ComplexD = cbrt ComplexD.One
  +            let a : MyCustomNumericTypeExtensionTestTypeForInternalTesting = cbrt (MyCustomNumericTypeExtensionTestTypeForInternalTesting())
               ()
               
           let sqrWorking() =
  
positive.code:     let inline smoothstep (edge0 : ^a) (edge1 : ^a) (x : ^b) =
          smoothstepAux Unchecked.defaultof<Fun> edge0 edge1 x
  
      module private CompilerTests =
  
          let fsharpCoreWorking() =
  
  
negative.code:             static member inline Saturate(x : float) = x |> max 0.0 |> min 1.0
              static member inline Saturate(x : float32) = x |> max 0.0f |> min 1.0f
              static member inline Saturate(x : decimal) = x |> max 0m |> min 1m
              
          type Signs =
              static member inline Signum (a : ^a) =
                  if a < LanguagePrimitives.GenericZero< ^a> then -LanguagePrimitives.GenericOne
                  elif a > LanguagePrimitives.GenericZero< ^a> then LanguagePrimitives.GenericOne
                  else LanguagePrimitives.GenericZero< ^a >
                  
              static member inline Signumi (a : ^a) =
                  if a < LanguagePrimitives.GenericZero< ^a> then -1
                  elif a > LanguagePrimitives.GenericZero< ^a> then 1
                  else 0
  
          type Power() =
              static member inline Power(a : ^a, b : ^b) = Operators.( ** ) a b
              
              static member inline Pown(a : ^a, b : int) = Operators.pown a b
  
          
          type Log2() =
              static member inline Log2(a : ^a) =
                  log a / log (LanguagePrimitives.GenericOne + LanguagePrimitives.GenericOne)
              
  
      [<AutoOpen>]
      module private Aux =
          let inline signumAux (_ : ^z) (_ : ^y) (x : ^a) =
              ((^z or ^y or ^a) : (static member Signum : ^a  -> ^a) x)
  
          let inline signumiAux (_ : ^z) (_ : ^y) (x : ^a) =
              ((^z or ^y or ^a) : (static member Signumi : ^a  -> ^b) x)
  
          let inline powAux (_ : ^z) (_ : ^y) (x : ^a) (y : ^b) =
              ((^z or ^y or ^a or ^b or ^c) : (static member Power : ^a * ^b -> ^c) (x, y))
  
          let inline pownAux (_ : ^z) (_ : ^y) (x : ^a) (y : ^b) =
              ((^z or ^y or ^a or ^b or ^c) : (static member Pown : ^a * ^b -> ^c) (x, y))
  
          let inline log2Aux (_ : ^z) (_ : ^y) (x : ^a) =
              ((^z or ^y or ^a) : (static member Log2 : ^a  -> ^a) x)
  
          let inline cbrtAux (_ : ^z) (x : ^a) =
              ((^z or ^a) : (static member Cbrt : ^a  -> ^a) x)
  