anchor.diff:              // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_withc_inner_vref in opt.fs)
               // and devirtualizes calls to it based on type "T".
               let GenericHashWithComparerIntrinsic<'T> (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
  -                eliminate_tail_call_int (GenericSpecializeHash.Func.Invoke (iec, x))
  +                eliminate_tail_call_int (GenericSpecializeHash.Function<_>.Func.Invoke (iec, x))
  +
  +#else
  +
  +            /// Intrinsic for calls to depth-unlimited structural hashing that were not optimized by static conditionals.
  +            //
  +            // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_inner_vref in opt.fs)
  +            // and devirtualizes calls to it based on type "T".
  +            let GenericHashIntrinsic x = GenericHashParamObj fsEqualityComparerUnlimitedHashingPER (box(x))
  +
  +            /// Intrinsic for calls to depth-limited structural hashing that were not optimized by static conditionals.
  +            let LimitedGenericHashIntrinsic limit x = GenericHashParamObj (CountLimitedHasherPER(limit)) (box(x))
  +
  +            /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
  +            //
  +            // "iec" is assumed to be either fsEqualityComparerUnlimitedHashingER, fsEqualityComparerUnlimitedHashingPER or 
  +            // a CountLimitedHasherPER.
  +            //
  +            // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_withc_inner_vref in opt.fs)
  +            // and devirtualizes calls to it based on type "T".
  +            let GenericHashWithComparerIntrinsic<'T> (iec : System.Collections.IEqualityComparer) (x : 'T) : int =
  +                GenericHashParamObj iec (box(x))
  +#endif
                   
               /// Direct call to GetHashCode on the string type
               let inline HashString (s:string) = 
  
positive.code:                 interface IEqualityComparerInfo with
                      member __.Info = EqualityComparerInfo.PER
  
              /// Intrinsic for calls to depth-unlimited structural hashing that were not optimized by static conditionals.
              //
              // NOTE: The compiler optimizer is aware of this function (see uses of generic_hash_inner_vref in opt.fs)
              // and devirtualizes calls to it based on type "T".
              let GenericHashIntrinsic x = 
                  let iec = fsEqualityComparerUnlimitedHashingPER
                  eliminate_tail_call_int (GenericSpecializeHash.Func.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.Func.Invoke (iec, x))
  
              /// Intrinsic for a recursive call to structural hashing that was not optimized by static conditionals.
              //
  
negative.code:                   | _ -> 
                        x.GetHashCode()
  
              /// Fill in the implementation of CountLimitedHasherPER
              type CountLimitedHasherPER with
                  interface System.Collections.IEqualityComparer with
  