anchor.diff:                          if x.HasValue then x.Value.GetHashCode ()
                           else 0
   
  -                type StructStructualEquality<'a when 'a : struct and 'a :> IStructuralEquatable>() =
  -                    member __.GetHashCode (ec:IEqualityComparer, x:'a) = Calls.StructualEqualityGetHashCode<'a> (ec, x)
  +                type StructStructuralEquality<'a when 'a : struct and 'a :> IStructuralEquatable>() =
  +                    member __.GetHashCode (ec:IEqualityComparer, x:'a) = Calls.StructuralEqualityGetHashCode<'a> (ec, x)
   
                   type StructGetHashCode<'a when 'a : struct and 'a : equality>() =
                       member __.GetHashCode (_:IEqualityComparer, x:'a) = x.GetHashCode ()
   
  -                type RefTypeStructualEquality<'a when 'a : not struct and 'a :> IStructuralEquatable>() =
  -                    member __.GetHashCode (ec:IEqualityComparer, x:'a) = Calls.StructualEqualityGetHashCode<'a> (ec, x)
  +                type RefTypeStructuralEquality<'a when 'a : not struct and 'a :> IStructuralEquatable>() =
  +                    member __.GetHashCode (ec:IEqualityComparer, x:'a) = Calls.StructuralEqualityGetHashCode<'a> (ec, x)
   
                   type RefTypeGetHashCode<'a when 'a : not struct and 'a : equality>() =
                       member __.GetHashCode (_:IEqualityComparer, x:'a) = x.GetHashCode ()
   
  -                type RefTypeNullableStructualEquality<'a when 'a : not struct and 'a : null and 'a :> IStructuralEquatable>() =
  +                type RefTypeNullableStructuralEquality<'a when 'a : not struct and 'a : null and 'a :> IStructuralEquatable>() =
                       member __.GetHashCode (ec:IEqualityComparer, x:'a) =
                           match x with
                           | null -> 0
  -                        | _ -> Calls.StructualEqualityGetHashCode (ec, x)
  +                        | _ -> Calls.StructuralEqualityGetHashCode (ec, x)
   
                   type RefTypeNullableGetHashCode<'a when 'a : not struct and 'a : null and 'a : equality>() =
                       member __.GetHashCode (_:IEqualityComparer, x:'a) =
  
positive.code:                     upcast Delegate.CreateDelegate (makeGetHashCodeReturnType ty, instance, "GetHashCode")
  
                  type Calls =
                      static member StructualEqualityGetHashCode<'a when 'a :> IStructuralEquatable> (ec, x:'a) = x.GetHashCode (ec) 
                      
                  type NullableStructualEquality<'a when 'a : struct and 'a : (new : unit ->  'a) and 'a :> ValueType and 'a :> IStructuralEquatable>() =
                      member __.GetHashCode (ec:IEqualityComparer, x:Nullable<'a>) =
                          if x.HasValue then Calls.StructualEqualityGetHashCode<'a> (ec, x.Value)
                          else 0
  
                  type NullableGetHashCode<'a when 'a : struct and 'a : (new : unit ->  'a) and 'a :> ValueType and 'a : equality>() =
  
negative.code:                     let pass2 =
                          match pass1 with
                          | null ->
                              if t.IsValueType then make typedefof<StructGetHashCode<Exemplars.DummyTypes.ValueTypeEquatableInterfaces>>
                              elif t.IsSealed  then make typedefof<RefTypeNullableGetHashCode<Exemplars.DummyTypes.RefTypeEquatableInterfaces>>
                              else null
                          | f -> f
  
  