anchor.diff:                                  | _, _ -> x.Equals y
   
                       type Equality<'a when 'a : not struct and 'a : null and 'a : equality>() =
  -                        member __.GetHashCode (_:IEqualityComparer, x:'a) =
  -                            match x with
  -                            | null -> 0
  -                            | _ -> x.GetHashCode ()
  -
                           interface Specializations.IEssenceOfEquals<'a> with
                               member __.Ensorcel (_:IEqualityComparer, x:'a, y:'a) =
                                   match x, y with
  
positive.code:                                 | _, _ -> x.CompareTo y
  
                      type StructuralEquatable<'a when 'a : not struct and 'a : null and 'a :> IStructuralEquatable>() =
                          member __.GetHashCode (ec:IEqualityComparer, x:'a) =
                              match x with
                              | null -> 0
                              | _ -> x.GetHashCode (ec) 
  
                          interface Specializations.IEssenceOfEquals<'a> with
                              member __.Ensorcel (ec:IEqualityComparer, x:'a, y:'a) =
                                  match x, y with
  
negative.code:             // and devirtualizes calls to it based on type "T".
              let GenericHashIntrinsic x = 
                  let iec = fsEqualityComparerUnlimitedHashingPER
                  eliminate_tail_call_int (GenericSpecializeHash.Function<_>.Func.Ensorcel (iec, x))
  
              /// Intrinsic for calls to depth-limited structural hashing that were not optimized by static conditionals.
              let LimitedGenericHashIntrinsic limit x =
                  let iec = CountLimitedHasherPER limit
                  eliminate_tail_call_int (GenericSpecializeHash.Function<_>.Func.Ensorcel (iec, x))
  
              // used by tuples
              let inline GenericHashWithComparerIntrinsic_inline (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
                  GenericSpecializeHash.Function<_>.Func.Ensorcel (iec, x)
  
              /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
              //
  