anchor.diff:                          fun () -> equalityInterfaces ty
                           fun () -> defaultEquality tyRelation ty
                       |]
  +
  +                type IGetEssenceOfEqualsObj =
  +                    abstract Get : unit -> obj
                               
                   type Function<'relation, 'a>() =
                       static let func : Specializations.IEssenceOfEquals<'a> =
  
positive.code:                         fun () -> defaultGetHashCode t
                      |]
                              
                  type Function<'a>() =
                      static let func : Specializations.IEssenceOfGetHashCode<'a> =
                          match createGetHashCodeDelegate typeof<'a> with
                          | null -> raise (Exception "invalid logic")
                          | :? Specializations.IEssenceOfGetHashCode<'a> as f -> f
                          | f -> upcast Specializations.GetHashCodeTypes.FromFunc(unboxPrim f)
  
                      static member Func = func
  
              /// Intrinsic for calls to depth-unlimited structural hashing that were not optimized by static conditionals.
              //
  
negative.code:                         let d = GenericHashWithComparerIntrinsic_inline iec x.Item4 
                          eliminate_tail_call_int (cth (cth a b) (cth c d))
  
                  type TupleEssenceOfEquals<'a,'b,'c,'d,'e,
                                               'eq1,'eq2,'eq3,'eq4,'eq5
                                                  when 'eq1 :> Specializations.IEssenceOfEquals<'a> and 'eq1 : (new : unit -> 'eq1)
                                                   and 'eq2 :> Specializations.IEssenceOfEquals<'b> and 'eq2 : (new : unit -> 'eq2)
                                                   and 'eq3 :> Specializations.IEssenceOfEquals<'c> and 'eq3 : (new : unit -> 'eq3)
                                                   and 'eq4 :> Specializations.IEssenceOfEquals<'d> and 'eq4 : (new : unit -> 'eq4)
                                                   and 'eq5 :> Specializations.IEssenceOfEquals<'e> and 'eq5 : (new : unit -> 'eq5)>() =
                      interface Specializations.IEssenceOfEquals<System.Tuple<'a,'b,'c,'d,'e>> with
                          member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e>, y:System.Tuple<'a,'b,'c,'d,'e>) = 
                              match x, y with
                              | null, null -> true
                              | null, _ | _, null -> false
                              | _, _ ->
                                  match Specializations.FlaconOfEquals<'a, 'eq1>.Instance.Ensorcel (ec, x.Item1, y.Item1) with
                                  | false -> false
                                  | _ ->
                                  match Specializations.FlaconOfEquals<'b, 'eq2>.Instance.Ensorcel (ec, x.Item2, y.Item2) with
                                  | false -> false
                                  | _ ->
                                  match Specializations.FlaconOfEquals<'c, 'eq3>.Instance.Ensorcel (ec, x.Item3, y.Item3) with
                                  | false -> false
                                  | _ ->
                                  match Specializations.FlaconOfEquals<'d, 'eq4>.Instance.Ensorcel (ec, x.Item4, y.Item4) with
                                  | false -> false
                                  | _ ->
                                  Specializations.FlaconOfEquals<'e, 'eq5>.Instance.Ensorcel (ec, x.Item5, y.Item5)
  
                  type TupleEssenceOfGetHashCode<'a,'b,'c,'d,'e,
                                                   'ghc1,'ghc2,'ghc3,'ghc4,'ghc5
                                                      when 'ghc1 :> Specializations.IEssenceOfGetHashCode<'a> and 'ghc1 : (new : unit -> 'ghc1)
                                                       and 'ghc2 :> Specializations.IEssenceOfGetHashCode<'b> and 'ghc2 : (new : unit -> 'ghc2)
                                                       and 'ghc3 :> Specializations.IEssenceOfGetHashCode<'c> and 'ghc3 : (new : unit -> 'ghc3)
                                                       and 'ghc4 :> Specializations.IEssenceOfGetHashCode<'d> and 'ghc4 : (new : unit -> 'ghc4)
                                                       and 'ghc5 :> Specializations.IEssenceOfGetHashCode<'e> and 'ghc5 : (new : unit -> 'ghc5)>() =
                      interface Specializations.IEssenceOfGetHashCode<System.Tuple<'a,'b,'c,'d,'e>> with
                          member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e>) =
                              let a = Specializations.FlaconOfGetHashCode<'a,'ghc1>.Instance.Ensorcel (iec, x.Item1)
                              let b = Specializations.FlaconOfGetHashCode<'b,'ghc2>.Instance.Ensorcel (iec, x.Item2) 
                              let c = Specializations.FlaconOfGetHashCode<'c,'ghc3>.Instance.Ensorcel (iec, x.Item3)
                              let d = Specializations.FlaconOfGetHashCode<'d,'ghc4>.Instance.Ensorcel (iec, x.Item4) 
                              let e = Specializations.FlaconOfGetHashCode<'e,'ghc5>.Instance.Ensorcel (iec, x.Item5)
                              eliminate_tail_call_int (cth (cth (cth a b) (cth c d)) e)
  
                  type TupleEREqualityComparer<'a,'b,'c,'d,'e,'f>() =
                      member __.Equals (_:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f>, y:System.Tuple<'a,'b,'c,'d,'e,'f>) = 
  