anchor.diff:                                  | _ ->
                                   Specializations.FlaconOfEquals<'e, 'eq5>.Instance.Ensorcel (ec, x.Item5, y.Item5)
   
  +                [<Struct; NoComparison; NoEquality>]
                   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)>() =
  +                                                     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)
  
positive.code: *)
                  let inline cth a b = TupleUtils.combineTupleHashes a b
  
                  type TupleEREqualityComparer<'a>() =
                      member __.Equals (_:IEqualityComparer, x:System.Tuple<'a>, y:System.Tuple<'a>) = 
                          match x, y with
                          | null, null -> true
                          | null, _ | _, null -> false
                          | _, _ ->
                              GenericEqualityERIntrinsic_inline x.Item1 y.Item1
  
                      member __.GetHashCode (iec:IEqualityComparer, x:System.Tuple<'a>) = 
                          let a = (GenericHashWithComparerIntrinsic_inline iec x.Item1)
                          eliminate_tail_call_int a
  
                  type TupleEREqualityComparer<'a,'b>() =
                      member __.Equals (_:IEqualityComparer, x:System.Tuple<'a,'b>, y:System.Tuple<'a,'b>) = 
                          match x, y with
                          | null, null -> true
                          | null, _ | _, null -> false
                          | _, _ ->
                              match GenericEqualityERIntrinsic_inline x.Item1 y.Item1 with
                              | false -> false
                              | _ ->
                              GenericEqualityERIntrinsic_inline x.Item2 y.Item2
  
                      member __.GetHashCode (iec:IEqualityComparer, x:System.Tuple<'a,'b>) =
                          let a = (GenericHashWithComparerIntrinsic_inline iec x.Item1)
                          let b = (GenericHashWithComparerIntrinsic_inline iec x.Item2) 
                          eliminate_tail_call_int (cth a b)
  
                  type TupleEREqualityComparer<'a,'b,'c>() =
                      member __.Equals (_:IEqualityComparer, x:System.Tuple<'a,'b,'c>, y:System.Tuple<'a,'b,'c>) = 
                          match x, y with
                          | null, null -> true
                          | null, _ | _, null -> false
                          | _, _ ->
                              match GenericEqualityERIntrinsic_inline x.Item1 y.Item1 with
                              | false -> false
                              | _ ->
                              match GenericEqualityERIntrinsic_inline x.Item2 y.Item2 with
                              | false -> false
                              | _ ->
                              GenericEqualityERIntrinsic_inline x.Item3 y.Item3
  
                      member __.GetHashCode (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c>) =
                          let a = GenericHashWithComparerIntrinsic_inline iec x.Item1
                          let b = GenericHashWithComparerIntrinsic_inline iec x.Item2 
                          let c = GenericHashWithComparerIntrinsic_inline iec x.Item3 
                          eliminate_tail_call_int (cth (cth a b) c)
  
                  type TupleEREqualityComparer<'a,'b,'c,'d>() =
                      member __.Equals (_:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d>, y:System.Tuple<'a,'b,'c,'d>) = 
                          match x, y with
                          | null, null -> true
                          | null, _ | _, null -> false
                          | _, _ ->
                              match GenericEqualityERIntrinsic_inline x.Item1 y.Item1 with
                              | false -> false
                              | _ ->
                              match GenericEqualityERIntrinsic_inline x.Item2 y.Item2 with
                              | false -> false
                              | _ ->
                              match GenericEqualityERIntrinsic_inline x.Item3 y.Item3 with
                              | false -> false
                              | _ ->
                              GenericEqualityERIntrinsic_inline x.Item4 y.Item4
  
                      member __.GetHashCode (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d>) =
                          let a = GenericHashWithComparerIntrinsic_inline iec x.Item1
                          let b = GenericHashWithComparerIntrinsic_inline iec x.Item2 
                          let c = GenericHashWithComparerIntrinsic_inline iec x.Item3
                          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
  
negative.code:                     if ty.IsGenericType then
                          let tyDef = ty.GetGenericTypeDefinition ()
                          let tyDefArgs = ty.GetGenericArguments ()
                          if tyDef.Equals typedefof<Tuple<_>>       then
                              let t0 = (get tyDefArgs 0)
                              let ghc0 = (getEssenceOfGetHashCodeObj t0).GetType ()
  
                              let tt = typedefof<TupleEssenceOfGetHashCode<int,t>>
                              let zz = tt.MakeGenericType [| t0; ghc0; |] 
                              Activator.CreateInstance zz
                          elif tyDef.Equals typedefof<Tuple<_,_>>       then
                              let t0 = (get tyDefArgs 0)
                              let t1 = (get tyDefArgs 1)
                              let ghc0 = (getEssenceOfGetHashCodeObj t0).GetType ()
                              let ghc1 = (getEssenceOfGetHashCodeObj t1).GetType ()
  
                              let tt = typedefof<TupleEssenceOfGetHashCode<int,int,t,t>>
                              let zz = tt.MakeGenericType [| t0; t1; ghc0; ghc1 |] 
                              Activator.CreateInstance zz
                          elif tyDef.Equals typedefof<Tuple<_,_,_>>       then
                              let t0 = (get tyDefArgs 0)
                              let t1 = (get tyDefArgs 1)
                              let t2 = (get tyDefArgs 2)
                              let ghc0 = (getEssenceOfGetHashCodeObj t0).GetType ()
                              let ghc1 = (getEssenceOfGetHashCodeObj t1).GetType ()
                              let ghc2 = (getEssenceOfGetHashCodeObj t2).GetType ()
  
                              let tt = typedefof<TupleEssenceOfGetHashCode<int,int,int,t,t,t>>
                              let zz = tt.MakeGenericType [| t0; t1; t2; ghc0; ghc1; ghc2 |] 
                              Activator.CreateInstance zz
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_>>       then
                              let t0 = (get tyDefArgs 0)
                              let t1 = (get tyDefArgs 1)
                              let t2 = (get tyDefArgs 2)
                              let t3 = (get tyDefArgs 3)
                              let ghc0 = (getEssenceOfGetHashCodeObj t0).GetType ()
                              let ghc1 = (getEssenceOfGetHashCodeObj t1).GetType ()
                              let ghc2 = (getEssenceOfGetHashCodeObj t2).GetType ()
                              let ghc3 = (getEssenceOfGetHashCodeObj t3).GetType ()
  
                              let tt = typedefof<TupleEssenceOfGetHashCode<int,int,int,int,t,t,t,t>>
                              let zz = tt.MakeGenericType [| t0; t1; t2; t3; ghc0; ghc1; ghc2; ghc3 |] 
                              Activator.CreateInstance zz
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_>>       then
                              let t0 = (get tyDefArgs 0)
                              let t1 = (get tyDefArgs 1)
                              let t2 = (get tyDefArgs 2)
  