anchor.diff:              // The compiler optimizer is aware of this function (see use of generic_equality_er_inner_vref in opt.fs)
               // and devirtualizes calls to it based on "T".
               let GenericEqualityERIntrinsic (x : 'T) (y : 'T) : bool =
  -                eliminate_tail_call_bool (GenericSpecializeEquals.Function<EquivalenceRelation,_>.Func.Ensorcel (fsEqualityComparerNoHashingER, x, y))
  +                eliminate_tail_call_bool (GenericSpecializeEquals.Function<EquivalenceRelation,_>.Invoker.Invoke (fsEqualityComparerNoHashingER, x, y))
                   
               /// Implements generic equality between two values using "comp" for recursive calls.
               //
  
positive.code:                 GenericSpecializeEquals.addTupleHandler (box tuplesEquals)
                  GenericSpecializeHash.addTupleHandler (box tuplesGetHashCode)
  
              type EssenceOfEqualityComparer<'a, 'eq, 'ghc
                      when 'eq  :> Specializations.IEssenceOfEquals<'a>      and 'eq : (new : unit -> 'eq)
                       and 'ghc :> Specializations.IEssenceOfGetHashCode<'a> and 'ghc : (new : unit -> 'ghc)>() =
  
negative.code:                         fun () -> defaultCompare ty
                      |]
  
                  [<AbstractClass>]
                  type ComparerInvoker<'a>() =
                      class
                          abstract Invoke : IComparer * 'a * 'a -> int
                      end
  
                  [<Sealed>]
                  type EssenceOfCompareWrapper<'a, 'eq 
                          when 'eq  :> Specializations.IEssenceOfCompareTo<'a> and 'eq : (new : unit -> 'eq)>() =
                      inherit ComparerInvoker<'a>()
                  
                      override __.Invoke (comp, x:'a, y:'a) =
                          Specializations.FlaconOfComparer<'a, 'eq>.Instance.Ensorcel (comp, x, y)
  
                  let makeComparerInvoker (ty:Type) comp =
                      let wrapperTypeDef = typedefof<EssenceOfCompareWrapper<int,Specializations.ComparerTypes.Int32>>
                      let wrapperType = wrapperTypeDef.MakeGenericType [| ty; comp |]
                      Activator.CreateInstance wrapperType
  
                  type Function<'relation, 'a>() =
                      static let essenceType : Type = 
                          match createCompareDelegate typeof<'relation> typeof<'a> with
                          | null -> raise (Exception "invalid logic")
                          | f -> f.GetType()
  
                      static let invoker : ComparerInvoker<'a> =
                          unboxPrim (makeComparerInvoker typeof<'a> essenceType)
  
                      static member Invoker = invoker
  
                      interface mos.IGetType with
                          member __.Get () = essenceType
  
              /// Compare two values of the same generic type, using "comp".
              //
  