anchor.diff:  
                       interface mos.IGetType with
                           member __.Get () = essenceType
  +                and Helpers =
  +                    static member getEssenceOfGetHashCodeType ty =
  +                        let getHashCode = mos.makeGenericType<Function<_>> [|ty|]
  +                        match Activator.CreateInstance getHashCode with
  +                        | :? mos.IGetType as getter -> getter.Get ()
  +                        | _ -> raise (Exception "invalid logic")
  +
  +                    static member tuplesGetHashCode (ty:Type) : Type =
  +                        if ty.IsGenericType then
  +                            let tyDef = ty.GetGenericTypeDefinition ()
  +                            let tyDefArgs = ty.GetGenericArguments ()
  +                            let create = mos.compositeType Helpers.getEssenceOfGetHashCodeType tyDefArgs
  +                            if   tyDef.Equals typedefof<Tuple<_>>               then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,t>>
  +                            elif tyDef.Equals typedefof<Tuple<_,_>>             then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,int,t,t>>
  +                            elif tyDef.Equals typedefof<Tuple<_,_,_>>           then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,int,int,t,t,t>>
  +                            elif tyDef.Equals typedefof<Tuple<_,_,_,_>>         then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,int,int,int,t,t,t,t>>
  +                            elif tyDef.Equals typedefof<Tuple<_,_,_,_,_>>       then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,int,int,int,int,t,t,t,t,t>>
  +                            elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_>>     then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,int,int,int,int,int,t,t,t,t,t,t>>
  +                            elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_>>   then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,int,int,int,int,int,int,t,t,t,t,t,t,t>>
  +                            elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_,_>> then create typedefof<TuplesGetHashCode.TupleEssenceOfGetHashCode<int,int,int,int,int,int,int,int,t,t,t,t,t,t,t,t>>
  +                            else null
  +                        else null
   
               /// Intrinsic for calls to depth-unlimited structural hashing that were not optimized by static conditionals.
               //
  
positive.code:                     member __.Info = EqualityComparerInfo.ER }
  
              module GenericSpecializeEquals =
                  let mutable private tupleHandler = null
                  let addTupleHandler f =
                      match box tupleHandler with
                      | null -> tupleHandler <- f
                      | _ -> raise (Exception "invalid logic")
  
                  let tuples tyRelation ty =
                      match box tupleHandler with
                      | :? (Type -> Type -> Type) as handler -> handler tyRelation ty
                      | _ -> null
  
                  let floatingPointTypes (tyRelation:Type) (ty:Type) =
                      match tyRelation with
                      | r when r.Equals typeof<PartialEquivalenceRelation> ->
  
negative.code: 
                      interface mos.IGetType with
                          member __.Get () = essenceType
                  and Helpers =
                      static member getEssenceOfEqualsType tyRelation ty =
                          let equals = mos.makeGenericType<Function<_,_>> [| tyRelation; ty|]
                          match Activator.CreateInstance equals with
                          | :? mos.IGetType as getter -> getter.Get ()
                          | _ -> raise (Exception "invalid logic")
  
                      static member tuplesEquals (tyRelation:Type) (ty:Type) : Type =
                          if ty.IsGenericType then
                              let tyDef = ty.GetGenericTypeDefinition ()
                              let tyDefArgs = ty.GetGenericArguments ()
                              let create = mos.compositeType (Helpers.getEssenceOfEqualsType tyRelation) tyDefArgs
                              if   tyDef.Equals typedefof<Tuple<_>>               then create typedefof<TupleEquals.TupleEssenceOfEquals<int,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_>>             then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_>>           then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_>>         then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_>>       then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,u,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_>>     then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,int,u,u,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_>>   then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,int,int,u,u,u,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_,_>> then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,int,int,int,u,u,u,u,u,u,u,u>>
                              else null
                          else null
  
  
              /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
              //
  