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:                     if ty.IsGenericType then
                          let tyDef = ty.GetGenericTypeDefinition ()
                          let tyDefArgs = ty.GetGenericArguments ()
                          if tyDef.Equals typedefof<Tuple<_,_,_,_,_>>       then
                              let t0 = (get tyDefArgs 0)
                              let t1 = (get tyDefArgs 1)
                              let t2 = (get tyDefArgs 2)
  
negative.code: *)
                  let inline cth a b = TupleUtils.combineTupleHashes a b
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfEquals<'a,
                                               'eq1
                                                  when 'eq1 :> Specializations.IEssenceOfEquals<'a> and 'eq1 : (new : unit -> 'eq1)> =
                      interface Specializations.IEssenceOfEquals<System.Tuple<'a>> with
                          member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a>, y:System.Tuple<'a>) = 
                              match x, y with
                              | null, null -> true
                              | null, _ | _, null -> false
                              | _, _ ->
                                  Specializations.FlaconOfEquals<'a, 'eq1>.Instance.Ensorcel (ec, x.Item1, y.Item1)
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfGetHashCode<'a,
                                                   'ghc1
                                                      when 'ghc1 :> Specializations.IEssenceOfGetHashCode<'a> and 'ghc1 : (new : unit -> 'ghc1)> =
                      interface Specializations.IEssenceOfGetHashCode<System.Tuple<'a>> with
                          member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a>) =
                              let a = Specializations.FlaconOfGetHashCode<'a,'ghc1>.Instance.Ensorcel (iec, x.Item1)
                              eliminate_tail_call_int a
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfEquals<'a,'b,
                                               'eq1,'eq2
                                                  when 'eq1 :> Specializations.IEssenceOfEquals<'a> and 'eq1 : (new : unit -> 'eq1)
                                                   and 'eq2 :> Specializations.IEssenceOfEquals<'b> and 'eq2 : (new : unit -> 'eq2)> =
                      interface Specializations.IEssenceOfEquals<System.Tuple<'a,'b>> with
                          member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b>, y:System.Tuple<'a,'b>) = 
                              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
                                  | _ ->
                                  Specializations.FlaconOfEquals<'b, 'eq2>.Instance.Ensorcel (ec, x.Item2, y.Item2)
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfGetHashCode<'a,'b,
                                                   'ghc1,'ghc2
                                                      when 'ghc1 :> Specializations.IEssenceOfGetHashCode<'a> and 'ghc1 : (new : unit -> 'ghc1)
                                                       and 'ghc2 :> Specializations.IEssenceOfGetHashCode<'b> and 'ghc2 : (new : unit -> 'ghc2)> =
                      interface Specializations.IEssenceOfGetHashCode<System.Tuple<'a,'b>> with
                          member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a,'b>) =
                              let a = Specializations.FlaconOfGetHashCode<'a,'ghc1>.Instance.Ensorcel (iec, x.Item1)
                              let b = Specializations.FlaconOfGetHashCode<'b,'ghc2>.Instance.Ensorcel (iec, x.Item2) 
                              eliminate_tail_call_int (cth a b)
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfEquals<'a,'b,'c,
                                               'eq1,'eq2,'eq3
                                                  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)> =
                      interface Specializations.IEssenceOfEquals<System.Tuple<'a,'b,'c>> with
                          member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c>, y:System.Tuple<'a,'b,'c>) = 
                              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
                                  | _ ->
                                  Specializations.FlaconOfEquals<'c, 'eq3>.Instance.Ensorcel (ec, x.Item3, y.Item3)
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfGetHashCode<'a,'b,'c,
                                                   'ghc1,'ghc2,'ghc3
                                                      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)> =
                      interface Specializations.IEssenceOfGetHashCode<System.Tuple<'a,'b,'c>> with
                          member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c>) =
                              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)
                              eliminate_tail_call_int (cth (cth a b) c)
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfEquals<'a,'b,'c,'d,
                                               'eq1,'eq2,'eq3,'eq4
                                                  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)> =
                      interface Specializations.IEssenceOfEquals<System.Tuple<'a,'b,'c,'d>> with
                          member __.Ensorcel (ec: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 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
                                  | _ ->
                                  Specializations.FlaconOfEquals<'d, 'eq4>.Instance.Ensorcel (ec, x.Item4, y.Item4)
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfGetHashCode<'a,'b,'c,'d,
                                                   'ghc1,'ghc2,'ghc3,'ghc4
                                                      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)> =
                      interface Specializations.IEssenceOfGetHashCode<System.Tuple<'a,'b,'c,'d>> with
                          member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d>) =
                              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) 
                              eliminate_tail_call_int (cth (cth a b) (cth c d))
  
                  [<Struct; NoComparison; NoEquality>]
                  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
  