anchor.diff:                  interface IEqualityComparerInfo with
                       member __.Info = EqualityComparerInfo.PER
   
  -#if FX_ATLEAST_40 // should probably create some compilation flag for this stuff
  -
               // functionality of GenericSpecializedHash should match GenericHashParamObj, or return null
               // for fallback to that funciton. 
               module GenericSpecializeHash =
  
positive.code:             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.
              //
  
negative.code:                   interface IEqualityComparerInfo with
                      member __.Info = EqualityComparerInfo.ER }
  
              module GenericSpecializeEquals =
                  let makeInstance (ct:Type) (def:Type) : obj =
                      let concrete = def.MakeGenericType [|ct|]
  