anchor.diff:                    interface IEqualityComparerInfo with
                       member __.Info = EqualityComparerInfo.ER }
   
  +            // eliminate_tail_call_xxx are to elimate tail calls which are a problem with value types > 64 bits
  +            // and the 64-bit JIT due to the amd64 calling convention which needs to do some magic.
  +            let inline eliminate_tail_call_int x = 0 + x
  +            let inline eliminate_tail_call_bool x =
  +                // previously: not (not (x))
  +                // but found that the following also removes tail calls, although this could obviously
  +                // change if the fsharp optimizer is changed...
  +                match x with
  +                | true -> true
  +                | false -> false
  +
  +#if FX_ATLEAST_40 // should probably create some compilation flag for this stuff
               type private EquivalenceRelation = class end
               type private PartialEquivalenceRelation = class end
  -
  -            type GenericSpecializeEqualsOther =
  -#if FX_ATLEAST_40
  -#else
  -            | ReferenceTypeStructuralEquality   = 0
  -#endif
  -            | GenericEqualityObj_ER             = 2 
  -            | GenericEqualityObj_PER            = 3
   
               module GenericSpecializeEquals =
                   let standardTypes (ty:Type) : obj =
  
positive.code:                     eliminate_tail_call_bool (EqualityComparer<'T>.Default.Equals (x, y))
                  | _ ->
                      eliminate_tail_call_bool (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)
              //
  
negative.code:                         | f -> unboxPrim f
  
                      static member Func = func
  
              /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
              //
  