anchor.diff:              type GenericComparer with
                   interface System.Collections.IComparer with
                       override c.Compare(x:obj,y:obj) = GenericCompare c (x,y)
  -            
  +
               /// The unique object for comparing values in PER mode (where local exceptions are thrown when NaNs are compared)
  -            let fsComparerPER        = GenericComparer(true)  
  +            let fsComparerPER_gt        = GenericComparer ComparerType.PER_gt
  +            let fsComparerPER_lt        = GenericComparer ComparerType.PER_lt
   
               /// The unique object for comparing values in ER mode (where "0" is returned when NaNs are compared)
  -            let fsComparerER = GenericComparer(false) 
  +            let fsComparerER = GenericComparer ComparerType.ER
   
               type GenericSpecializeCompareTo<'a>() =
                   static let generalize (func:Func<IComparer,'aa,'aa,int>) =
  
positive.code:             /// 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
                      
              
              /// 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
              
               
              /// 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
                      
              
              
              /// 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
  
  
              /// Compare two values of the same generic type, in ER mode, with static optimizations 
  
negative.code:                         | _ -> raise (Exception "invalid logic")
  
                      let pass1 =
                          // These do not require seperate versions based on equivalence relations; defer to helper 
                          match pass0 with
                          | null -> standardTypes ty
                          | f -> f
  