anchor.diff:              /// Generic less-than. Uses comparison implementation in PER mode but catches 
               /// the local exception that is thrown when NaN's are compared.
               let GenericLessThanIntrinsic (x:'T) (y:'T) = 
  -                try
  -                    (# "clt" (GenericComparisonWithComparerIntrinsic fsComparerPER x y) 0 : bool #)
  -                with
  -                    | e when System.Runtime.CompilerServices.RuntimeHelpers.Equals(e, NaNException) -> false
  -                    
  +                (# "clt" (GenericComparisonWithComparerIntrinsic fsComparerPER_lt x y) 0 : bool #)
               
               /// Generic greater-than. Uses comparison implementation in PER mode but catches 
               /// the local exception that is thrown when NaN's are compared.
               let GenericGreaterThanIntrinsic (x:'T) (y:'T) = 
  -                try
  -                    (# "cgt" (GenericComparisonWithComparerIntrinsic fsComparerPER x y) 0 : bool #)
  -                with
  -                    | e when System.Runtime.CompilerServices.RuntimeHelpers.Equals(e, NaNException) -> false
  -            
  +                (# "cgt" (GenericComparisonWithComparerIntrinsic fsComparerPER_gt x y) 0 : bool #)
                
               /// Generic greater-than-or-equal. Uses comparison implementation in PER mode but catches 
               /// the local exception that is thrown when NaN's are compared.
               let GenericGreaterOrEqualIntrinsic (x:'T) (y:'T) = 
  -                try
  -                    (# "cgt" (GenericComparisonWithComparerIntrinsic fsComparerPER x y) (-1) : bool #)
  -                with
  -                    | e when System.Runtime.CompilerServices.RuntimeHelpers.Equals(e, NaNException) -> false
  -                    
  -            
  +                (# "cgt" (GenericComparisonWithComparerIntrinsic fsComparerPER_gt x y) (-1) : bool #)
               
               /// Generic less-than-or-equal. Uses comparison implementation in PER mode but catches 
               /// the local exception that is thrown when NaN's are compared.
               let GenericLessOrEqualIntrinsic (x:'T) (y:'T) = 
  -                try
  -                    (# "clt" (GenericComparisonWithComparerIntrinsic fsComparerPER x y) 1 : bool #)
  -                with
  -                    | e when System.Runtime.CompilerServices.RuntimeHelpers.Equals(e, NaNException) -> false
  +                (# "clt" (GenericComparisonWithComparerIntrinsic fsComparerPER_lt x y) 1 : bool #)
   
   
               /// Compare two values of the same generic type, in ER mode, with static optimizations 
  
positive.code:                         | _ -> raise (Exception "invalid logic")
  
                      let pass1 =
                          // These do not require seperate versions based on equivalence relations, so defer to helper object
                          match pass0 with
                          | null -> standardTypes ty
                          | f -> f
  
negative.code:                    | (:? IStructuralComparable as x),_ ->
                         x.CompareTo(yobj,comp)
                     // Check for IComparable
                     | (:? System.IComparable as x),_ ->
                          if comp.ComparerType.Equals ComparerType.ER then
                              x.CompareTo yobj
                          else 
                              let getNaNResult () =
                                  match comp.ComparerType with
                                  | ComparerType.PER_gt -> 2
                                  | ComparerType.PER_lt -> -2
                                  | _ -> raise (Exception "Invalid logic")
  
                              match xobj, yobj with
                              | (:? float as x), (:? float as y) -> 
                                  if System.Double.IsNaN x || System.Double.IsNaN y
                                      then getNaNResult ()
                                      else x.CompareTo y
                              | (:? float32 as x), (:? float32 as y) -> 
                                  if System.Single.IsNaN x || System.Single.IsNaN y
                                      then getNaNResult ()
                                      else x.CompareTo y
                              | _ -> x.CompareTo yobj
  
                     | (:? nativeint as x),(:? nativeint as y) -> if (# "clt" x y : bool #) then (-1) else (# "cgt" x y : int #)
                     | (:? unativeint as x),(:? unativeint as y) -> if (# "clt.un" x y : bool #) then (-1) else (# "cgt.un" x y : int #)
                     | _,(:? IStructuralComparable as yc) ->
  