anchor.diff:                      | _ -> null
   
                   let standardTypes (t:Type) : obj =
  -                    if   t.Equals typeof<bool>       then box (Func<IEqualityComparer,bool      ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<float>      then box (Func<IEqualityComparer,float     ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<sbyte>      then box (Func<IEqualityComparer,sbyte     ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<int16>      then box (Func<IEqualityComparer,int16     ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<int32>      then box (Func<IEqualityComparer,int32     ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<int64>      then box (Func<IEqualityComparer,int64     ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<byte>       then box (Func<IEqualityComparer,byte      ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<uint16>     then box (Func<IEqualityComparer,uint16    ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<uint32>     then box (Func<IEqualityComparer,uint32    ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<uint64>     then box (Func<IEqualityComparer,uint64    ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<nativeint>  then box (Func<IEqualityComparer,nativeint ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<unativeint> then box (Func<IEqualityComparer,unativeint,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<char>       then box (Func<IEqualityComparer,char      ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<string>     then box (Func<IEqualityComparer,string    ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<decimal>    then box (Func<IEqualityComparer,decimal   ,int>(fun _ a -> a.GetHashCode()))
  -                    elif t.Equals typeof<float32>    then box (Func<IEqualityComparer,float32   ,int>(fun _ a -> a.GetHashCode()))
  +                    if   t.Equals typeof<bool>       then box (Specializations.FlaconOfGetHashCode<bool      , Specializations.GetHashCodeTypes.Bool      >.Instance)
  +                    elif t.Equals typeof<float>      then box (Specializations.FlaconOfGetHashCode<float     , Specializations.GetHashCodeTypes.Float     >.Instance)
  +                    elif t.Equals typeof<sbyte>      then box (Specializations.FlaconOfGetHashCode<sbyte     , Specializations.GetHashCodeTypes.Sbyte     >.Instance)
  +                    elif t.Equals typeof<int16>      then box (Specializations.FlaconOfGetHashCode<int16     , Specializations.GetHashCodeTypes.Int16     >.Instance)
  +                    elif t.Equals typeof<int32>      then box (Specializations.FlaconOfGetHashCode<int32     , Specializations.GetHashCodeTypes.Int32     >.Instance)
  +                    elif t.Equals typeof<int64>      then box (Specializations.FlaconOfGetHashCode<int64     , Specializations.GetHashCodeTypes.Int64     >.Instance)
  +                    elif t.Equals typeof<byte>       then box (Specializations.FlaconOfGetHashCode<byte      , Specializations.GetHashCodeTypes.Byte      >.Instance)
  +                    elif t.Equals typeof<uint16>     then box (Specializations.FlaconOfGetHashCode<uint16    , Specializations.GetHashCodeTypes.Uint16    >.Instance)
  +                    elif t.Equals typeof<uint32>     then box (Specializations.FlaconOfGetHashCode<uint32    , Specializations.GetHashCodeTypes.Uint32    >.Instance)
  +                    elif t.Equals typeof<uint64>     then box (Specializations.FlaconOfGetHashCode<uint64    , Specializations.GetHashCodeTypes.Uint64    >.Instance)
  +                    elif t.Equals typeof<nativeint>  then box (Specializations.FlaconOfGetHashCode<nativeint , Specializations.GetHashCodeTypes.Nativeint >.Instance)
  +                    elif t.Equals typeof<unativeint> then box (Specializations.FlaconOfGetHashCode<unativeint, Specializations.GetHashCodeTypes.Unativeint>.Instance)
  +                    elif t.Equals typeof<char>       then box (Specializations.FlaconOfGetHashCode<char      , Specializations.GetHashCodeTypes.Char      >.Instance)
  +                    elif t.Equals typeof<string>     then box (Specializations.FlaconOfGetHashCode<string    , Specializations.GetHashCodeTypes.String    >.Instance)
  +                    elif t.Equals typeof<decimal>    then box (Specializations.FlaconOfGetHashCode<decimal   , Specializations.GetHashCodeTypes.Decimal   >.Instance)
  +                    elif t.Equals typeof<float32>    then box (Specializations.FlaconOfGetHashCode<float32   , Specializations.GetHashCodeTypes.Float32   >.Instance)
                       else null
   
                   type GenericHashParamObject<'a>() =
  -                    member __.GetHashCode (iec:IEqualityComparer, x:'a) = GenericHashParamObj iec (box x)
  +                    interface Specializations.IEssenceOfGetHashCode<'a> with
  +                        member __.Ensorcel (iec:IEqualityComparer, x:'a) = GenericHashParamObj iec (box x)
   
                   let arrays (t:Type) : obj =
                       if t.IsArray || typeof<System.Array>.IsAssignableFrom t then
                           // TODO: Future; for now just default back to previous functionality
  -                        makeGetHashCodeDelegate t t typedefof<GenericHashParamObject<_>>
  +                        makeInstance t typedefof<GenericHashParamObject<_>>
                       else null
   
                   let nullableType (t:Type) : obj =
                       if t.IsGenericType && ((t.GetGenericTypeDefinition ()).Equals typedefof<System.Nullable<_>>) then
                           let underlying = get (t.GetGenericArguments()) 0
  -                        let make = makeGetHashCodeDelegate t underlying 
  +                        let make = makeInstance underlying 
                           
                           if typeof<IStructuralEquatable>.IsAssignableFrom underlying then make Exemplars.nullableStructuralEquatable
                           else                                                             make Exemplars.nullableEquality
                       else null
   
                   let structualEquatable (t:Type): obj =
  -                    let make = makeGetHashCodeDelegate t t
  +                    let make = makeInstance t
   
                       if   t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t then make Exemplars.valueTypeStructuralEquatable
                       elif typeof<IStructuralEquatable>.IsAssignableFrom t                  then make Exemplars.refTypeStructuralEquatable
                       else null
   
                   let sealedTypes (t:Type): obj =
  -                    let make = makeGetHashCodeDelegate t t
  +                    let make = makeInstance t
   
                       if t.IsValueType then make Exemplars.valueTypeEquality
                       elif t.IsSealed  then make Exemplars.refTypeEquality
                       else null
   
                   let defaultGetHashCode ty =
  -                    makeGetHashCodeDelegate ty ty typedefof<GenericHashParamObject<_>>
  +                    makeInstance ty typedefof<GenericHashParamObject<_>>
   
                   let createGetHashCodeDelegate (t:Type) : obj =
                       mos.takeFirstNonNull [|
  
positive.code:                                 x.CompareTo y
  
                      type StructuralEquatable<'a when 'a : struct and 'a :> IStructuralEquatable>() =
                          member __.GetHashCode (ec:IEqualityComparer, x:'a) = x.GetHashCode (ec) 
  
                          interface Specializations.IEssenceOfEquals<'a> with
                              member __.Ensorcel (ec:IEqualityComparer, x:'a, y:'a) =
                                  x.Equals (box y, ec) 
  
negative.code:             // and devirtualizes calls to it based on type "T".
              let GenericHashIntrinsic x = 
                  let iec = fsEqualityComparerUnlimitedHashingPER
                  eliminate_tail_call_int (GenericSpecializeHash.Function<_>.Func.Ensorcel (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<_>.Func.Ensorcel (iec, x))
  
              // used by tuples
              let inline GenericHashWithComparerIntrinsic_inline (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
                  GenericSpecializeHash.Function<_>.Func.Ensorcel (iec, x)
  
              /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
              //
  