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 =
  -                GenericSpecializeHash.Func.Invoke (iec, x)
  +                // The "((x)* -1)* -1" is to elimate tail calls which are a problem with value types > 64 bits
  +                ((GenericSpecializeHash.Func.Invoke (iec, x))* -1)* -1
                   
               /// Direct call to GetHashCode on the string type
               let inline HashString (s:string) = 
  
positive.code:             // 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 =
                  GenericSpecializeEqualsWithRelation<EquivalenceRelation,_>.Func.Invoke (fsEqualityComparerNoHashingER, x, y)
                  
              /// Implements generic equality between two values using "comp" for recursive calls.
              //
  
negative.code:             // The compiler optimizer is aware of this function  (see use of generic_equality_per_inner_vref in opt.fs)
              // and devirtualizes calls to it based on "T".
              let GenericEqualityIntrinsic (x : 'T) (y : 'T) : bool = 
                  // The "not (not (x))" is to elimate tail calls which are a problem with value types > 64 bits
                  not (not (GenericSpecializeEqualsWithRelation<PartialEquivalenceRelation,_>.Func.Invoke (fsEqualityComparerNoHashingPER, x, y)))
  
                  
              /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
              //
  