anchor.diff:              // and devirtualizes calls to it based on type "T".
               let GenericHashIntrinsic x = 
                   let iec = fsEqualityComparerUnlimitedHashingPER
  -                eliminate_tail_call_int (GenericSpecializeHash.Function<PartialEquivalenceRelation,_>.Invoker.Invoke (iec, x))
  +                eliminate_tail_call_int (GenericSpecializeHash.Function<_>.Invoker.Invoke (iec, x))
   
               /// Intrinsic for calls to depth-limited structural hashing that were not optimized by static conditionals.
               let LimitedGenericHashIntrinsic limit x =
                   let iec = CountLimitedHasherPER limit
  -                eliminate_tail_call_int (GenericSpecializeHash.Function<PartialEquivalenceRelation,_>.Invoker.Invoke (iec, x))
  +                eliminate_tail_call_int (GenericSpecializeHash.Function<_>.Invoker.Invoke (iec, x))
   
               /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
               //
  
positive.code:                 let defaultGetHashCode ty =
                      mos.makeType ty typedefof<GenericHashParamObject<_>>
  
                  let getGetHashCodeEssenceType (tyRelation:Type) (t:Type) tuples : Type =
                      mos.takeFirstNonNull [|
                          fun () -> tuples tyRelation t
                          fun () -> standardTypes t
                          fun () -> compilerGenerated tyRelation t
                          fun () -> arrays t
                          fun () -> nullableType t
                          fun () -> structualEquatable t
  
negative.code:                     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<GetHashCodeTypes.Tuple<int,t>>
                              elif tyDef.Equals typedefof<Tuple<_,_>>             then create typedefof<GetHashCodeTypes.Tuple<int,int,t,t>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_>>           then create typedefof<GetHashCodeTypes.Tuple<int,int,int,t,t,t>>
  