anchor.diff:                              let d = phantom<'ghc4>.Ensorcel (iec, x.Item4) 
                               let e = phantom<'ghc5>.Ensorcel (iec, x.Item5)
                               eliminate_tail_call_int (cth (cth (cth a b) (cth c d)) e)
  -
  -                [<Struct; NoComparison; NoEquality>]
  -                type Tuple<'a,'b,'c,'d,'e,'f,
  -                            'ghc1,'ghc2,'ghc3,'ghc4,'ghc5,'ghc6
  -                                when 'ghc1 :> IEssenceOfGetHashCode<'a> and 'ghc1 : (new : unit -> 'ghc1) and 'ghc1 : struct
  -                                    and 'ghc2 :> IEssenceOfGetHashCode<'b> and 'ghc2 : (new : unit -> 'ghc2) and 'ghc2 : struct
  -                                    and 'ghc3 :> IEssenceOfGetHashCode<'c> and 'ghc3 : (new : unit -> 'ghc3) and 'ghc3 : struct
  -                                    and 'ghc4 :> IEssenceOfGetHashCode<'d> and 'ghc4 : (new : unit -> 'ghc4) and 'ghc4 : struct
  -                                    and 'ghc5 :> IEssenceOfGetHashCode<'e> and 'ghc5 : (new : unit -> 'ghc5) and 'ghc5 : struct
  -                                    and 'ghc6 :> IEssenceOfGetHashCode<'f> and 'ghc6 : (new : unit -> 'ghc6) and 'ghc6 : struct
  -                                                                                                                                > =
  -                    interface IEssenceOfGetHashCode<System.Tuple<'a,'b,'c,'d,'e,'f>> with
  -                        member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f>) =
  -                            let a = phantom<'ghc1>.Ensorcel (iec, x.Item1)
  -                            let b = phantom<'ghc2>.Ensorcel (iec, x.Item2) 
  -                            let c = phantom<'ghc3>.Ensorcel (iec, x.Item3)
  -                            let d = phantom<'ghc4>.Ensorcel (iec, x.Item4) 
  -                            let e = phantom<'ghc5>.Ensorcel (iec, x.Item5)
  -                            let f = phantom<'ghc6>.Ensorcel (iec, x.Item6)
  -                            eliminate_tail_call_int (cth (cth (cth a b) (cth c d)) (cth e f))
  -
  -                [<Struct; NoComparison; NoEquality>]
  -                type Tuple<'a,'b,'c,'d,'e,'f,'g,
  -                            'ghc1,'ghc2,'ghc3,'ghc4,'ghc5,'ghc6,'ghc7
  -                                when 'ghc1 :> IEssenceOfGetHashCode<'a> and 'ghc1 : (new : unit -> 'ghc1) and 'ghc1 : struct
  -                                    and 'ghc2 :> IEssenceOfGetHashCode<'b> and 'ghc2 : (new : unit -> 'ghc2) and 'ghc2 : struct
  -                                    and 'ghc3 :> IEssenceOfGetHashCode<'c> and 'ghc3 : (new : unit -> 'ghc3) and 'ghc3 : struct
  -                                    and 'ghc4 :> IEssenceOfGetHashCode<'d> and 'ghc4 : (new : unit -> 'ghc4) and 'ghc4 : struct
  -                                    and 'ghc5 :> IEssenceOfGetHashCode<'e> and 'ghc5 : (new : unit -> 'ghc5) and 'ghc5 : struct
  -                                    and 'ghc6 :> IEssenceOfGetHashCode<'f> and 'ghc6 : (new : unit -> 'ghc6) and 'ghc6 : struct
  -                                    and 'ghc7 :> IEssenceOfGetHashCode<'g> and 'ghc7 : (new : unit -> 'ghc7) and 'ghc7 : struct
  -                                                                                                                                > =
  -                    interface IEssenceOfGetHashCode<System.Tuple<'a,'b,'c,'d,'e,'f,'g>> with
  -                        member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f,'g>) =
  -                            let a = phantom<'ghc1>.Ensorcel (iec, x.Item1)
  -                            let b = phantom<'ghc2>.Ensorcel (iec, x.Item2) 
  -                            let c = phantom<'ghc3>.Ensorcel (iec, x.Item3)
  -                            let d = phantom<'ghc4>.Ensorcel (iec, x.Item4) 
  -                            let e = phantom<'ghc5>.Ensorcel (iec, x.Item5)
  -                            let f = phantom<'ghc6>.Ensorcel (iec, x.Item6)
  -                            let g = phantom<'ghc7>.Ensorcel (iec, x.Item7)
  -                            eliminate_tail_call_int (cth (cth (cth a b) (cth c d)) (cth (cth e f) g))
  -
  -                [<Struct; NoComparison; NoEquality>]
  -                type Tuple<'a,'b,'c,'d,'e,'f,'g,'h,
  -                            'ghc1,'ghc2,'ghc3,'ghc4,'ghc5,'ghc6,'ghc7,'ghc8
  -                                when 'ghc1 :> IEssenceOfGetHashCode<'a> and 'ghc1 : (new : unit -> 'ghc1) and 'ghc1 : struct
  -                                    and 'ghc2 :> IEssenceOfGetHashCode<'b> and 'ghc2 : (new : unit -> 'ghc2) and 'ghc2 : struct
  -                                    and 'ghc3 :> IEssenceOfGetHashCode<'c> and 'ghc3 : (new : unit -> 'ghc3) and 'ghc3 : struct
  -                                    and 'ghc4 :> IEssenceOfGetHashCode<'d> and 'ghc4 : (new : unit -> 'ghc4) and 'ghc4 : struct
  -                                    and 'ghc5 :> IEssenceOfGetHashCode<'e> and 'ghc5 : (new : unit -> 'ghc5) and 'ghc5 : struct
  -                                    and 'ghc6 :> IEssenceOfGetHashCode<'f> and 'ghc6 : (new : unit -> 'ghc6) and 'ghc6 : struct
  -                                    and 'ghc7 :> IEssenceOfGetHashCode<'g> and 'ghc7 : (new : unit -> 'ghc7) and 'ghc7 : struct
  -                                    and 'ghc8 :> IEssenceOfGetHashCode<'h> and 'ghc8 : (new : unit -> 'ghc8) and 'ghc8 : struct
  -                                                                                                                                > =
  -                    interface IEssenceOfGetHashCode<System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>> with
  -                        member __.Ensorcel (iec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>) =
  -                            let a = phantom<'ghc1>.Ensorcel (iec, x.Item1)
  -                            let b = phantom<'ghc2>.Ensorcel (iec, x.Item2) 
  -                            let c = phantom<'ghc3>.Ensorcel (iec, x.Item3)
  -                            let d = phantom<'ghc4>.Ensorcel (iec, x.Item4) 
  -                            let e = phantom<'ghc5>.Ensorcel (iec, x.Item5)
  -                            let f = phantom<'ghc6>.Ensorcel (iec, x.Item6)
  -                            let g = phantom<'ghc7>.Ensorcel (iec, x.Item7)
  -                            let h = phantom<'ghc8>.Ensorcel (iec, x.Rest)
  -                            eliminate_tail_call_int (cth (cth (cth a b) (cth c d)) (cth (cth e f) (cth g h)))
   
               module CommonEqualityTypes =
                   module Nullable =
  
positive.code:                 [<Struct; NoComparison; NoEquality>] type Char       = interface IEssenceOfEquals<char      > with member __.Ensorcel (_,x,y) = (# "ceq" x y : bool #)
                  [<Struct; NoComparison; NoEquality>] type String     = interface IEssenceOfEquals<string    > with member __.Ensorcel (_,x,y) = System.String.Equals((# "" x : string #),(# "" y : string #))
                  [<Struct; NoComparison; NoEquality>] type Decimal    = interface IEssenceOfEquals<decimal   > with member __.Ensorcel (_,x,y) = System.Decimal.op_Equality((# "" x:decimal #), (# "" y:decimal #))
  
                  [<Struct; NoComparison; NoEquality>]
                  type Tuple<'a,
                              'eq1
                                  when 'eq1 :> IEssenceOfEquals<'a> and 'eq1 : (new : unit -> 'eq1) and 'eq1 : struct
                                                                                                                      > =
                      interface 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
                              | _, _ ->
                                  phantom<'eq1>.Ensorcel (ec, x.Item1, y.Item1)
  
                  [<Struct; NoComparison; NoEquality>]
                  type Tuple<'a,'b,
  
negative.code:                                 | _ ->
                                  phantom<'eq5>.Ensorcel (ec, x.Item5, y.Item5)
  
              module GetHashCodeTypes =
                  [<Struct; NoComparison; NoEquality>] type Bool       = interface IEssenceOfGetHashCode<bool      > with member __.Ensorcel (_,a) = a.GetHashCode()
                  [<Struct; NoComparison; NoEquality>] type Float      = interface IEssenceOfGetHashCode<float     > with member __.Ensorcel (_,a) = a.GetHashCode()
  