anchor.diff:                          | _ -> raise (Exception "invalid logic")
   
                       let pass1 =
  -                        // These do not require seperate versions based on equivalence relations, so defer to helper object
  +                        // These do not require seperate versions based on equivalence relations; defer to helper 
                           match pass0 with
                           | null -> standardTypes ty
                           | f -> f
  
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:                         | f -> f
  
                      let pass3 =
                          // These do not require seperate versions based on equivalence relations, defer to helper
                          match pass2 with
                          | null -> equalityInterfaces ty
                          | f -> f
  