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
  -
               module GenericSpecializeEquals =
                   let standardTypes (ty:Type) : obj =
                       match ty with
  
positive.code:             | ER     = 0 
              | PER_lt = 1
              | PER_gt = 2
              
              type GenericComparer(comparerType:ComparerType) = 
                  interface System.Collections.IComparer 
                  member  c.ComparerType = comparerType
  
negative.code:                  when 'T : decimal     = System.Decimal.Compare((# "" x:decimal #), (# "" y:decimal #))
  
  
  
  
              /// Compare two values of the same generic type, in ER mode, with static optimizations 
  