anchor.diff:              // 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))
  +                match GenericSpecializeEqualsWithRelation<UnknownEquivalenceRelation,_>.Func with
  +                | null -> comp.Equals((box x),(box y))
  +                | func -> func.Invoke (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 =
                  GenericHashParamObj iec (box(x))
                  
              /// Direct call to GetHashCode on the string type
              let inline HashString (s:string) = 
  
negative.code:                   | _ -> 
                       HashCombine 10 (x.GetLength(0)) (x.GetLength(1)) 
  
              type GenericSpecializeHash<'a>() =
                  static let generalize (func:Func<'aa,int>) =
                      match box func with
                      | :? Func<'a,int> as f -> f
                      | _ -> raise (Exception "invalid logic")
  
                  static let _func =
                      match typeof<'a> with
                      | t when t.Equals typeof<bool>       -> generalize (Func<_,_>(fun (a:bool)       -> a.GetHashCode()))
                      | t when t.Equals typeof<sbyte>      -> generalize (Func<_,_>(fun (a:sbyte)      -> a.GetHashCode()))
                      | t when t.Equals typeof<int16>      -> generalize (Func<_,_>(fun (a:int16)      -> a.GetHashCode()))
                      | t when t.Equals typeof<int32>      -> generalize (Func<_,_>(fun (a:int32)      -> a.GetHashCode()))
                      | t when t.Equals typeof<int64>      -> generalize (Func<_,_>(fun (a:int64)      -> a.GetHashCode()))
                      | t when t.Equals typeof<byte>       -> generalize (Func<_,_>(fun (a:byte)       -> a.GetHashCode()))
                      | t when t.Equals typeof<uint16>     -> generalize (Func<_,_>(fun (a:uint16)     -> a.GetHashCode()))
                      | t when t.Equals typeof<uint32>     -> generalize (Func<_,_>(fun (a:uint32)     -> a.GetHashCode()))
                      | t when t.Equals typeof<uint64>     -> generalize (Func<_,_>(fun (a:uint64)     -> a.GetHashCode()))
                      | t when t.Equals typeof<nativeint>  -> generalize (Func<_,_>(fun (a:nativeint)  -> a.GetHashCode()))
                      | t when t.Equals typeof<unativeint> -> generalize (Func<_,_>(fun (a:unativeint) -> a.GetHashCode()))
                      | t when t.Equals typeof<char>       -> generalize (Func<_,_>(fun (a:char)       -> a.GetHashCode()))
                      | t when t.Equals typeof<string>     -> generalize (Func<_,_>(fun (a:string)     -> a.GetHashCode()))
                      | t when t.Equals typeof<decimal>    -> generalize (Func<_,_>(fun (a:decimal)    -> a.GetHashCode()))
                      | t when t.Equals typeof<float>      -> generalize (Func<_,_>(fun (a:float)      -> a.GetHashCode()))
                      | t when t.Equals typeof<float32>    -> generalize (Func<_,_>(fun (a:float32)    -> a.GetHashCode()))
                      | _ -> null
                              
                  static member Func = _func
  
              // Core implementation of structural hashing, corresponds to pseudo-code in the 
              // F# Language spec.  Searches for the IStructuralHash interface, otherwise uses GetHashCode().
              // Arrays are structurally hashed through a separate technique.
  