anchor.diff:          let inline log2Aux (_ : ^z) (x : ^a) =
               ((^z or ^a) : (static member Log2 : ^a  -> ^a) x)
   
  -        let inline squareAux (_ : ^z) (_ : ^w) (x : ^a) =
  -            ((^z or ^w or ^a) : (static member Square : ^a -> ^a) x)
  -
           let inline cbrtAux (_ : ^z) (x : ^a) =
               ((^z or ^a) : (static member Cbrt : ^a  -> ^a) x)
           
  -        let inline minAux (_ : ^z) (_ : ^w) (x : ^a) (y : ^b) =
  -            ((^z or ^w or ^a or ^b) : (static member Min : ^a * ^b -> ^a) (x, y))
  -
  -        let inline maxAux (_ : ^z) (_ : ^w) (x : ^a) (y : ^b) =
  -            ((^z or ^w or ^a or ^b) : (static member Max : ^a * ^b -> ^a) (x, y))
  -
  -        let inline clampAux (_ : ^z) (a : ^b) (b : ^b) (x : ^a) =
  -            ((^z or ^a or ^b) : (static member Clamp : ^a * ^b * ^b -> ^a) (x, a, b))
  +        let inline minAux (_ : ^z) (x : ^a) (y : ^b) =
  +            ((^z or ^a or ^b or ^c) : (static member Min : ^a * ^b -> ^c) (x, y))
  +
  +        let inline maxAux (_ : ^z) (x : ^a) (y : ^b) =
  +            ((^z or ^a or ^b or ^c) : (static member Max : ^a * ^b -> ^c) (x, y))
  +
  +        let inline clampAux (_ : ^z) (a : ^a) (b : ^b) (x : ^c) =
  +            ((^z or ^a or ^b or ^c or ^d) : (static member Clamp : ^c * ^a * ^b -> ^d) (x, a, b))
   
       /// Resolves to the zero value for any scalar or vector type.
       let inline zero< ^T when ^T : (static member Zero : ^T) > : ^T =
  
positive.code:         let two : ^b = one + one
          let three : ^b = two + one
          let t = saturate ((x - edge0) / (edge1 - edge0))
          t * t * (three - two * t)
negative.code:     let inline log2 x =
          log2Aux Unchecked.defaultof<Fun> x
  
      /// Returns x^2
      let inline sqr (x : ^a) = x * x
          //squareAux Unchecked.defaultof<Fun> Unchecked.defaultof<Helpers.NativeInt> x
  
      /// Returns the cubic root of x.
      let inline cbrt x =
          cbrtAux Unchecked.defaultof<Fun> x
  
      /// Returns the smaller of x and y.
      let inline min x y = minAux Unchecked.defaultof<Helpers.MinMaxHelpers> x y
  
      /// Returns the larger of x and y.
      let inline max x y = maxAux Unchecked.defaultof<Helpers.MinMaxHelpers> x y
  
      /// Clamps x to the interval [a, b].
      let inline clamp a b x = clampAux Unchecked.defaultof<Helpers.MinMaxHelpers> a b x
  
      /// Clamps x to the interval [0, 1].
      let inline saturate (x : ^a) =
  