anchor.diff:              // 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 = 
  -                match GenericSpecializeEqualsWithRelation<PartialEquivalenceRelation,_>.Func with
  -                | null -> GenericEqualityObj false fsEqualityComparerNoHashingPER ((box x), (box y))
  -                | func -> func.Invoke (x, y)
  +                GenericSpecializeEqualsWithRelation<PartialEquivalenceRelation,_>.Func.Invoke (fsEqualityComparerNoHashingPER, x, y)
                   
               /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
               //
  
positive.code:             // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_withc_inner_vref in opt.fs)
              // and devirtualizes calls to it based on type "T".
              let GenericHashWithComparerIntrinsic<'T> (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
                  match GenericSpecializeHash.Func with
                  | null -> GenericHashParamObj iec (box x)
                  | func -> func.Invoke (iec, x)
                  
              /// Direct call to GetHashCode on the string type
              let inline HashString (s:string) = 
  
negative.code:             let fsComparerER = GenericComparer(false) 
  
              type GenericSpecializeCompareTo<'a>() =
                  static let generalize (func:Func<IComparer,'aa,'aa,int>) =
                      match box func with
                      | :? Func<IComparer,'a,'a,int> as f -> f
                      | _ -> raise (Exception "invalid logic")
  
                  static let _specialized =
                      match typeof<'a> with
                      | t when t.Equals typeof<bool>       -> generalize (Func<_,_,_,_>(fun _ (x:bool)      y -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)))
                      | t when t.Equals typeof<sbyte>      -> generalize (Func<_,_,_,_>(fun _ (x:sbyte)     y -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)))
                      | t when t.Equals typeof<int16>      -> generalize (Func<_,_,_,_>(fun _ (x:int16)     y -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)))
                      | t when t.Equals typeof<int32>      -> generalize (Func<_,_,_,_>(fun _ (x:int32)     y -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)))
                      | t when t.Equals typeof<int64>      -> generalize (Func<_,_,_,_>(fun _ (x:int64)     y -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)))
                      | t when t.Equals typeof<nativeint>  -> generalize (Func<_,_,_,_>(fun _ (x:nativeint) y -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)))
                      | t when t.Equals typeof<byte>       -> generalize (Func<_,_,_,_>(fun _ (x:byte)      y -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)))
                      | t when t.Equals typeof<uint16>     -> generalize (Func<_,_,_,_>(fun _ (x:uint16)    y -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)))
                      | t when t.Equals typeof<uint32>     -> generalize (Func<_,_,_,_>(fun _ (x:uint32)    y -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)))
                      | t when t.Equals typeof<uint64>     -> generalize (Func<_,_,_,_>(fun _ (x:uint64)    y -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)))
                      | t when t.Equals typeof<unativeint> -> generalize (Func<_,_,_,_>(fun _ (x:unativeint)y -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)))
                      | t when t.Equals typeof<char>       -> generalize (Func<_,_,_,_>(fun _ (x:char)      y -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)))
                      | t when t.Equals typeof<string>     -> generalize (Func<_,_,_,_>(fun _ (x:string)    y -> System.String.CompareOrdinal((# "" x : string #) ,(# "" y : string #))))
                      | t when t.Equals typeof<decimal>    -> generalize (Func<_,_,_,_>(fun _ (x:decimal)   y -> System.Decimal.Compare((# "" x:decimal #), (# "" y:decimal #))))
                      | _ -> null
  
                  static let _func = 
                      match _specialized with
                      | null -> Func<_,_,_,_>(fun (comp:IComparer) x y -> comp.Compare (box x, box y))
                      | f -> f
                              
                  static member Func = _func
                      
  