anchor.diff:                                  Specializations.FlaconOfEquals<'e, 'eq5>.Instance.Ensorcel (ec, x.Item5, y.Item5)
   
                   [<Struct; NoComparison; NoEquality>]
  +                type TupleEssenceOfEquals<'a,'b,'c,'d,'e,'f,
  +                                             'eq1,'eq2,'eq3,'eq4,'eq5,'eq6
  +                                                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)
  +                                                 and 'eq6 :> Specializations.IEssenceOfEquals<'f> and 'eq6 : (new : unit -> 'eq6)
  +                                                                                                                                    > =
  +                    interface Specializations.IEssenceOfEquals<System.Tuple<'a,'b,'c,'d,'e,'f>> with
  +                        member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f>, y:System.Tuple<'a,'b,'c,'d,'e,'f>) = 
  +                            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
  +                                | _ ->
  +                                match Specializations.FlaconOfEquals<'e, 'eq5>.Instance.Ensorcel (ec, x.Item5, y.Item5) with
  +                                | false -> false
  +                                | _ ->
  +                                Specializations.FlaconOfEquals<'f, 'eq6>.Instance.Ensorcel (ec, x.Item6, y.Item6)
  +
  +                [<Struct; NoComparison; NoEquality>]
  +                type TupleEssenceOfEquals<'a,'b,'c,'d,'e,'f,'g,
  +                                             'eq1,'eq2,'eq3,'eq4,'eq5,'eq6,'eq7
  +                                                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)
  +                                                 and 'eq6 :> Specializations.IEssenceOfEquals<'f> and 'eq6 : (new : unit -> 'eq6)
  +                                                 and 'eq7 :> Specializations.IEssenceOfEquals<'g> and 'eq7 : (new : unit -> 'eq7)
  +                                                                                                                                    > =
  +                    interface Specializations.IEssenceOfEquals<System.Tuple<'a,'b,'c,'d,'e,'f,'g>> with
  +                        member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f,'g>, y:System.Tuple<'a,'b,'c,'d,'e,'f,'g>) = 
  +                            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
  +                                | _ ->
  +                                match Specializations.FlaconOfEquals<'e, 'eq5>.Instance.Ensorcel (ec, x.Item5, y.Item5) with
  +                                | false -> false
  +                                | _ ->
  +                                match Specializations.FlaconOfEquals<'f, 'eq6>.Instance.Ensorcel (ec, x.Item6, y.Item6) with
  +                                | false -> false
  +                                | _ ->
  +                                Specializations.FlaconOfEquals<'g, 'eq7>.Instance.Ensorcel (ec, x.Item7, y.Item7)
  +
  +                [<Struct; NoComparison; NoEquality>]
  +                type TupleEssenceOfEquals<'a,'b,'c,'d,'e,'f,'g,'h,
  +                                             'eq1,'eq2,'eq3,'eq4,'eq5,'eq6,'eq7,'eq8
  +                                                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)
  +                                                 and 'eq6 :> Specializations.IEssenceOfEquals<'f> and 'eq6 : (new : unit -> 'eq6)
  +                                                 and 'eq7 :> Specializations.IEssenceOfEquals<'g> and 'eq7 : (new : unit -> 'eq7)
  +                                                 and 'eq8 :> Specializations.IEssenceOfEquals<'h> and 'eq8 : (new : unit -> 'eq8)
  +                                                                                                                                    > =
  +                    interface Specializations.IEssenceOfEquals<System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>> with
  +                        member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>, y:System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>) = 
  +                            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
  +                                | _ ->
  +                                match Specializations.FlaconOfEquals<'e, 'eq5>.Instance.Ensorcel (ec, x.Item5, y.Item5) with
  +                                | false -> false
  +                                | _ ->
  +                                match Specializations.FlaconOfEquals<'f, 'eq6>.Instance.Ensorcel (ec, x.Item6, y.Item6) with
  +                                | false -> false
  +                                | _ ->
  +                                match Specializations.FlaconOfEquals<'g, 'eq7>.Instance.Ensorcel (ec, x.Item7, y.Item7) with
  +                                | false -> false
  +                                | _ ->
  +                                Specializations.FlaconOfEquals<'h, 'eq8>.Instance.Ensorcel (ec, x.Rest, y.Rest)
  +
  +                [<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 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 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 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 TupleEssenceOfGetHashCode<'a,'b,'c,'d,'e,
                                                    'ghc1,'ghc2,'ghc3,'ghc4,'ghc5
                                                       when 'ghc1 :> Specializations.IEssenceOfGetHashCode<'a> and 'ghc1 : (new : unit -> 'ghc1)
  
positive.code:                                 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)
  
negative.code:                     | _ -> raise (Exception "invalid logic")
  
                  type t = Specializations.GetHashCodeTypes.Int32
                  let tuplesGetHashCode (ty:Type) : obj =
                      if ty.IsGenericType then
                          let tyDef = ty.GetGenericTypeDefinition ()
                          let tyDefArgs = ty.GetGenericArguments ()
                          let create = mos.compositeCreator getEssenceOfGetHashCodeType tyDefArgs
                          if   tyDef.Equals typedefof<Tuple<_>>               then create typedefof<TupleEssenceOfGetHashCode<int,t>>
                          elif tyDef.Equals typedefof<Tuple<_,_>>             then create typedefof<TupleEssenceOfGetHashCode<int,int,t,t>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_>>           then create typedefof<TupleEssenceOfGetHashCode<int,int,int,t,t,t>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_>>         then create typedefof<TupleEssenceOfGetHashCode<int,int,int,int,t,t,t,t>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_>>       then create typedefof<TupleEssenceOfGetHashCode<int,int,int,int,int,t,t,t,t,t>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_>>     then create typedefof<TupleEssenceOfGetHashCode<int,int,int,int,int,int,t,t,t,t,t,t>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_>>   then create typedefof<TupleEssenceOfGetHashCode<int,int,int,int,int,int,int,t,t,t,t,t,t,t>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_,_>> then create typedefof<TupleEssenceOfGetHashCode<int,int,int,int,int,int,int,int,t,t,t,t,t,t,t,t>>
                          else null
                      else null
  
                  type u = Specializations.EqualsTypes.Int32
                  let tuplesEquals (_relation:Type) (ty:Type) : obj =
                      if ty.IsGenericType && _relation.Equals typeof<EquivalenceRelation> then
                          let tyDef = ty.GetGenericTypeDefinition ()
                          let tyDefArgs = ty.GetGenericArguments ()
                          let create = mos.compositeCreator getEssenceOfEqualsType tyDefArgs
                          if   tyDef.Equals typedefof<Tuple<_>>               then create typedefof<TupleEssenceOfEquals<int,u>>
                          elif tyDef.Equals typedefof<Tuple<_,_>>             then create typedefof<TupleEssenceOfEquals<int,int,u,u>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_>>           then create typedefof<TupleEssenceOfEquals<int,int,int,u,u,u>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_>>         then create typedefof<TupleEssenceOfEquals<int,int,int,int,u,u,u,u>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_>>       then create typedefof<TupleEssenceOfEquals<int,int,int,int,int,u,u,u,u,u>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_>>     then create typedefof<TupleEssenceOfEquals<int,int,int,int,int,int,u,u,u,u,u,u>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_>>   then create typedefof<TupleEssenceOfEquals<int,int,int,int,int,int,int,u,u,u,u,u,u,u>>
                          elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_,_>> then create typedefof<TupleEssenceOfEquals<int,int,int,int,int,int,int,int,u,u,u,u,u,u,u,u>>
                          else null
                      else null
  
  