anchor.diff:              let GenericLessOrEqualIntrinsic (x:'T) (y:'T) = 
                   (# "clt" (GenericComparisonWithComparerIntrinsic fsComparerPER_lt x y) 1 : bool #)
   
  -#else
  -            /// Compare two values of the same generic type, using "comp".
  -            //
  -            // "comp" is assumed to be either fsComparerPER or fsComparerER (and hence 'Compare' is implemented via 'GenericCompare').
  -            //
  -            // NOTE: the compiler optimizer is aware of this function and devirtualizes in the 
  -            // cases where it is known how a particular type implements generic comparison.
  -            let GenericComparisonWithComparerIntrinsic<'T> (comp:System.Collections.IComparer) (x:'T) (y:'T) : int = 
  -                comp.Compare(box x, box y)
  -
  -
  -            /// Generic comparison. Implements ER mode (where "0" is returned when NaNs are compared)
  -            //
  -            // The compiler optimizer is aware of this function  (see use of generic_comparison_inner_vref in opt.fs)
  -            // and devirtualizes calls to it based on "T".
  -            let GenericComparisonIntrinsic<'T> (x:'T) (y:'T) : int = 
  -                GenericComparisonWithComparerIntrinsic fsComparerER x y
  -
  -            /// Generic less-than. Uses comparison implementation in PER mode but catches 
  -            /// the local exception that is thrown when NaN's are compared.
  -            let GenericLessThanIntrinsic (x:'T) (y:'T) = 
  -                (# "clt" (GenericComparisonWithComparerIntrinsic fsComparerPER_lt x y) 0 : bool #)
  -            
  -            /// Generic greater-than. Uses comparison implementation in PER mode but catches 
  -            /// the local exception that is thrown when NaN's are compared.
  -            let GenericGreaterThanIntrinsic (x:'T) (y:'T) = 
  -                (# "cgt" (GenericComparisonWithComparerIntrinsic fsComparerPER_gt x y) 0 : bool #)
  -             
  -            /// Generic greater-than-or-equal. Uses comparison implementation in PER mode but catches 
  -            /// the local exception that is thrown when NaN's are compared.
  -            let GenericGreaterOrEqualIntrinsic (x:'T) (y:'T) = 
  -                (# "cgt" (GenericComparisonWithComparerIntrinsic fsComparerPER_gt x y) (-1) : bool #)
  -            
  -            /// Generic less-than-or-equal. Uses comparison implementation in PER mode but catches 
  -            /// the local exception that is thrown when NaN's are compared.
  -            let GenericLessOrEqualIntrinsic (x:'T) (y:'T) = 
  -                (# "clt" (GenericComparisonWithComparerIntrinsic fsComparerPER_lt x y) 1 : bool #)
  -#endif
               /// Compare two values of the same generic type, in either PER or ER mode, but include static optimizations
               /// for various well-known cases.
               //
  
positive.code:                     eliminate_tail_call_bool (EqualityComparer<'T>.Default.Equals (x, y))
                  | _ ->
                      eliminate_tail_call_bool (comp.Equals (box x, box y))
  #else
              /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
              //
              // The compiler optimizer is aware of this function  (see use of generic_equality_per_inner_vref in opt.fs)
              // and devirtualizes calls to it based on "T".
              let GenericEqualityIntrinsic (x : 'T) (y : 'T) : bool = 
                  GenericEqualityObj false fsEqualityComparerNoHashingPER ((box x), (box y))
                  
              /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
              //
              // ER semantics is used for recursive calls when implementing .Equals(that) for structural data, see the code generated for record and union types in augment.fs
              //
              // The compiler optimizer is aware of this function (see use of generic_equality_er_inner_vref in opt.fs)
              // and devirtualizes calls to it based on "T".
              let GenericEqualityERIntrinsic (x : 'T) (y : 'T) : bool =
                  GenericEqualityObj true fsEqualityComparerNoHashingER ((box x), (box y))
                  
              /// Implements generic equality between two values using "comp" for recursive calls.
              //
              // The compiler optimizer is aware of this function  (see use of generic_equality_withc_inner_vref in opt.fs)
              // and devirtualizes calls to it based on "T", and under the assumption that "comp" 
              // is either fsEqualityComparerNoHashingER or fsEqualityComparerNoHashingPER.
              let GenericEqualityWithComparerIntrinsic (comp : System.Collections.IEqualityComparer) (x : 'T) (y : 'T) : bool =
                  comp.Equals((box x),(box y))
             
  #endif
  
              /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
              //
  
negative.code:     open PrimReflectionAdapters
  
  #endif
  
      module BasicInlinedOperations =  
          let inline unboxPrim<'T>(x:obj) = (# "unbox.any !0" type ('T) x : 'T #)
  