anchor.diff:      let inline log2 x =
           log2Aux Unchecked.defaultof<Fun> x
   
  -    /// Returns x raised by the power of 2.
  -    let inline sqr (x : ^a) =
  -        squareAux Unchecked.defaultof<Fun> Unchecked.defaultof<Helpers.NativeInt> 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 (y : ^b) (x : ^a) : ^a =
  -        minAux Unchecked.defaultof<Fun> Unchecked.defaultof<Helpers.NativeInt> x y
  +    let inline min x y = minAux Unchecked.defaultof<Helpers.MinMaxHelpers> x y
   
       /// Returns the larger of x and y.
  -    let inline max (y : ^b) (x : ^a) : ^a =
  -        maxAux Unchecked.defaultof<Fun> Unchecked.defaultof<Helpers.NativeInt> x 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) (b : ^b) (x : ^a) : ^a =
  -        clampAux Unchecked.defaultof<Fun> a b x
  +    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) =
  
positive.code:         type Power() =
              static member inline Power(x : sbyte, y : sbyte) = pown x (int y)
              static member inline Power(x : int16, y : int16) = pown x (int y)
              static member inline Power(x : int32, y : int32) = pown x (int y)
              static member inline Power(x : int64, y : int64) = pown x (int y)
  
              static member inline Power(x : byte, y : byte) = pown x (int y)
  
negative.code:             static member inline Power(x : float32, y : float32) = x ** y
              static member inline Power(x : decimal, y : decimal) = Math.Pow(float x, float y) |> decimal
  
          type MinMaxHelpers() =
              static member inline Min<'a when 'a : comparison>(a : 'a, b : 'a) = Operators.min a b
  
              static member inline Min(a : float, b : V2d) = V2d.Min(b, a)
              static member inline Min(a : float, b : V3d) = V3d.Min(b, a)
              static member inline Min(a : float, b : V4d) = V4d.Min(b, a)
              static member inline Min(a : float32, b : V2f) = V2f.Min(b, a)
              static member inline Min(a : float32, b : V3f) = V3f.Min(b, a)
              static member inline Min(a : float32, b : V4f) = V4f.Min(b, a)
              static member inline Min(a : int, b : V2i) = V2i.Min(b, a)
              static member inline Min(a : int, b : V3i) = V3i.Min(b, a)
              static member inline Min(a : int, b : V4i) = V4i.Min(b, a)
              static member inline Min(a : int64, b : V2l) = V2l.Min(b, a)
              static member inline Min(a : int64, b : V3l) = V3l.Min(b, a)
              static member inline Min(a : int64, b : V4l) = V4l.Min(b, a)
  
  
  
              
              static member inline Max<'a when 'a : comparison>(a : 'a, b : 'a) = Operators.max a b
  
              static member inline Max(a : float, b : V2d) = V2d.Max(b, a)
              static member inline Max(a : float, b : V3d) = V3d.Max(b, a)
              static member inline Max(a : float, b : V4d) = V4d.Max(b, a)
              static member inline Max(a : float32, b : V2f) = V2f.Max(b, a)
              static member inline Max(a : float32, b : V3f) = V3f.Max(b, a)
              static member inline Max(a : float32, b : V4f) = V4f.Max(b, a)
              static member inline Max(a : int, b : V2i) = V2i.Max(b, a)
              static member inline Max(a : int, b : V3i) = V3i.Max(b, a)
              static member inline Max(a : int, b : V4i) = V4i.Max(b, a)
              static member inline Max(a : int64, b : V2l) = V2l.Max(b, a)
              static member inline Max(a : int64, b : V3l) = V3l.Max(b, a)
              static member inline Max(a : int64, b : V4l) = V4l.Max(b, a)
  
  
              static member inline Clamp(x : int, a : int, b : int) = Fun.Clamp(x, a, b)
              static member inline Clamp(x : float, a : float, b : float) = Fun.Clamp(x, a, b)
  
              static member inline Clamp< ^a when ^a : comparison>(x : ^a, min : ^a, max : ^a) =
                  if x > max then max
                  elif x < min then min
                  else x
  
  
  
  
      [<AutoOpen>]
      module private Aux =
  