anchor.diff:                          | null -> equalityInterfaces ty
                           | f -> f
   
  -#if FX_ATLEAST_40
                       let pass4 =
                           match pass3 with
                           | null ->
  
positive.code:                         | f -> unboxPrim f
  
                      static member Func = func
  #else
                      let pass4 =
                          match pass3 with
                          | null ->
                              // and if none of that works, then just fall back to default behavious of GenericEqualityObj
                              match tyRelation with
                              | r when r.Equals typeof<PartialEquivalenceRelation> ->
                                  box GenericSpecializeEqualsOther.GenericEqualityObj_PER
                              | r when r.Equals typeof<EquivalenceRelation>        ->
                                  box GenericSpecializeEqualsOther.GenericEqualityObj_ER
                              | _ -> raise (Exception "invalid logic")                    
                          | f -> f
  
                      pass4
                              
                  type Function<'relation, 'a>() =
                      static let funcAsObj : obj  =
                          match withRelation typeof<'relation> typeof<'a> with
                          | null -> raise (Exception "invalid logic")
                          | :? GenericSpecializeEqualsOther as t ->
                              match t with
                              | GenericSpecializeEqualsOther.ReferenceTypeStructuralEquality ->
                                  upcast Func<IEqualityComparer,'a,'a,bool>(fun ec a b ->
                                      match box a, box b with
                                      | null, null -> true
                                      | null, _    -> false
                                      | _,    null -> false
                                      | :? IStructuralEquatable as se, boxedb -> se.Equals (boxedb, ec)
                                      | _ -> raise (Exception "invalid logic"))
                              | GenericSpecializeEqualsOther.GenericEqualityObj_ER ->
                                  upcast Func<IEqualityComparer,'a,'a,bool>(fun (comp:IEqualityComparer) x y ->
                                      GenericEqualityObj true comp ((box x), (box y)))
                              | GenericSpecializeEqualsOther.GenericEqualityObj_PER ->
                                  upcast Func<IEqualityComparer,'a,'a,bool>(fun (comp:IEqualityComparer) x y ->
                                      GenericEqualityObj false comp ((box x), (box y)))
                              | _ -> raise (Exception "invalid logic")
                          | f -> f
  
                      static let func : Func<IEqualityComparer,'a, 'a, bool> = unboxPrim funcAsObj
  
                      static member Func = func
  #endif
  
              // 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_bool x = not (not (x))
              let inline eliminate_tail_call_int x = 0 + x
  
              /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
              //
  
negative.code: 
                      interface IEquatable<DummyRefTypeInterfaces> with
                          member __.Equals _ = raise (Exception "invalid logic")
  
                  let equalityInterfaces (t:Type) : obj =
                      let make = makeEquatableDelegate t t
  
                      if t.IsArray || typeof<System.Array>.IsAssignableFrom t then
                          // I could do something here, but I doubt it would have any real performance impact
                          null
  
                      elif t.IsGenericType && ((t.GetGenericTypeDefinition ()).Equals typedefof<System.Nullable<_>>) then
                          let nt = get (t.GetGenericArguments()) 0
                          let make = makeEquatableDelegate t nt 
  