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,_>.Invoker.Invoke (fsEqualityComparerNoHashingER, x, y))
  +                GenericEqualityObj true fsEqualityComparerNoHashingER ((box x), (box y))
                   
               /// Implements generic equality between two values using "comp" for recursive calls.
               //
               // The compiler optimizer is aware of this function  (see use of generic_equality_withc_inner_vref in opt.fs)
               // and devirtualizes calls to it based on "T", and under the assumption that "comp" 
               // is either fsEqualityComparerNoHashingER or fsEqualityComparerNoHashingPER.
  -            //
  -            // <<manofstick>> I think the above compiler optimization is misplaced, as it means that you can end
  -            // up with differing functionality of generic and non-generic types when the IStructuralEquatable
  -            // this is doucmented here- https://github.com/Microsoft/visualfsharp/pull/513#issuecomment-117995410
               let GenericEqualityWithComparerIntrinsic (comp : System.Collections.IEqualityComparer) (x : 'T) (y : 'T) : bool =
  -                match comp with
  -                | :? IEqualityComparerInfo as info ->
  -                    match info.Info with
  -                    | EqualityComparerInfo.ER  -> eliminate_tail_call_bool (GenericEqualityERIntrinsic x y)
  -                    | EqualityComparerInfo.PER -> eliminate_tail_call_bool (GenericEqualityIntrinsic x y)
  -                    | _ -> raise (Exception "invalid logic")
  -                | c when obj.ReferenceEquals (c, EqualityComparer<'T>.Default)   ->
  -                    eliminate_tail_call_bool (EqualityComparer<'T>.Default.Equals (x, y))
  -                | _ ->
  -                    eliminate_tail_call_bool (comp.Equals (box x, box y))
  +                comp.Equals((box x),(box y))
  +                
   
               /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
               //
  
positive.code:             // same as a stable sort of the array. See Array.stableSortInPlace.
              //
              // REVIEW: in a future version we could extend this to include additional types 
              ty.Equals typeof<byte>
              || ty.Equals typeof<char>
              || ty.Equals typeof<sbyte>
              || ty.Equals typeof<int16>
              || ty.Equals typeof<int32>
              || ty.Equals typeof<int64>
              || ty.Equals typeof<uint16>
              || ty.Equals typeof<uint32>
              || ty.Equals typeof<uint64>
              || ty.Equals typeof<float>    
              || ty.Equals typeof<float32>
              || ty.Equals typeof<decimal>
  
          type FastGenericComparerTable_fCanBeNull<'T>() = 
              static let fCanBeNull : System.Collections.Generic.IComparer<'T>  = 
                  match getFastGenericComparerTable_fCanBeNull typeof<'T> with 
                  | true -> null
                  | false -> FastGenericComparerTable.Value
  
              static member ValueCanBeNullIfDefaultSemantics : System.Collections.Generic.IComparer<'T> = fCanBeNull
          
  
negative.code:                         new CountLimitedHasherPER(sz)
                  
                  interface IEqualityComparer 
  
              /// The implementation of IEqualityComparer, using unlimited depth for hashing and ER semantics for NaN equality.
              type UnlimitedHasherER() =
                  interface IEqualityComparer 
                  
              /// The implementation of IEqualityComparer, using unlimited depth for hashing and PER semantics for NaN equality.
              type UnlimitedHasherPER() =
                  interface IEqualityComparer
                      
  
              /// The unique object for unlimited depth for hashing and ER semantics for equality.
              let fsEqualityComparerUnlimitedHashingER = UnlimitedHasherER()
  
              /// The unique object for unlimited depth for hashing and PER semantics for equality.
              let fsEqualityComparerUnlimitedHashingPER = UnlimitedHasherPER()
               
              let inline HashCombine nr x y = (x <<< 1) + y + 631 * nr
  
  