@@ -159,3 +159,20 @@ def materialized(value: Iterable[_T]) -> Iterable[_T]:
         return list(value) if iter(value) is value else value
     except TypeError:
         return value
+
+
+def definition_of(klass: type, name: str) -> tuple[type, object] | None:
+    """The class in *klass*'s tree that defines *name*, and the definition itself, or ``None``.
+
+    Walked and read raw, which is the reading the interpreter does for an operator: no attribute access
+    on the class, so neither a metaclass nor a descriptor of the class's own gets to answer for it.
+
+    A definition of ``None`` reads as no definition, so a class declaring `__hash__ = None` reports the
+    hashable base above it.  Callers that care ask the class about `__hash__` directly, which is the
+    cheaper question anyway.
+    """
+    for base in type.__getattribute__(klass, "__mro__"):
+        found = type.__getattribute__(base, "__dict__").get(name)
+        if found is not None:
+            return base, found
+    return None
@@ -19,7 +19,7 @@
 from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any, cast
 
-from ._introspection import materialized
+from ._introspection import definition_of, materialized
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
@@ -121,17 +121,38 @@ def _kinds(items: Any) -> set[type] | None:
 
 
 def _safe(kinds: set[type] | None) -> bool:
-    """Whether every one of *kinds* hashes and compares by the same rule.
+    """Whether every one of *kinds* hashes and compares by the same rule."""
+    return kinds is not None and all(_agrees(kind) for kind in kinds)
+
+
+def _agrees(kind: type) -> bool:
+    """Whether this type's ``==`` and ``hash()`` answer consistently, so a set may stand in for a walk.
 
     Hashability is asked of the type, not tried on the value: an unhashable type carries
     `__hash__ = None`.  It is not implied by the rest of the rule, since a class can inherit identity
     equality and still declare itself unhashable, and without this the shortcut raised where it answered.
+
+    The third clause is what admits a subclass.  A name on the safe list is not enough on its own,
+    because that list holds exact types, and `IntEnum`, `StrEnum` and a plain `class Money(int)` all
+    took the quadratic walk although they answer exactly as their base does: four thousand of them cost
+    30 ms against 0.09 ms.  Asked of the owner of each definition rather than of the definition itself,
+    so a class that assigns `__hash__ = str.__hash__` beside an inherited `int.__eq__` is refused: its
+    owner is the class, not a safe type.  A base cannot supply the two from different safe types either,
+    since inheriting from two of them is a layout conflict the interpreter refuses.
     """
-    return kinds is not None and all(
-        kind.__hash__ is not None and (kind in _HASH_SAFE or kind.__eq__ is object.__eq__) for kind in kinds
+    return kind.__hash__ is not None and (
+        kind in _HASH_SAFE
+        or kind.__eq__ is object.__eq__
+        or (_owned_by_a_safe_type(kind, "__eq__") and _owned_by_a_safe_type(kind, "__hash__"))
     )
 
 
+def _owned_by_a_safe_type(kind: type, name: str) -> bool:
+    """Whether *kind* inherits *name* unchanged from one of the types on the safe list."""
+    found = definition_of(kind, name)
+    return found is not None and found[0] in _HASH_SAFE
+
+
 def _hash_safe(items: Any) -> bool:
     """Whether *items* may be indexed. Kept as a name of its own because the tests read better with it."""
     return _safe(_kinds(items))
 
@@ -25,7 +25,7 @@
 from collections import Counter
 from typing import TYPE_CHECKING, Final
 
-from ._engine._introspection import is_attrs_instance, is_mapping_like, is_model_dump_object
+from ._engine._introspection import definition_of, is_attrs_instance, is_mapping_like, is_model_dump_object
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Sequence
@@ -262,16 +262,10 @@ def _fields_of(value: object) -> dict | None:
 
 
 def _defined_as(klass: type, name: str) -> bool:
-    """Whether the definition of *name* the class tree carries is the one ``object`` carries.
-
-    Walked and read raw, which is the reading the interpreter does for an operator: no attribute access
-    on the class, so neither a metaclass nor a descriptor of the class's own gets to answer for it.
-    """
-    for base in type.__getattribute__(klass, "__mro__"):
-        found = type.__getattribute__(base, "__dict__").get(name)
-        if found is not None:
-            return found is object.__dict__[name]
-    return False  # pragma: no cover - `object` ends every tree and defines both names, so this is dead
+    """Whether the definition of *name* the class tree carries is the one ``object`` carries."""
+    found = definition_of(klass, name)
+    # pragma: no cover on the `None` half - `object` ends every tree and defines both names asked here
+    return found is not None and found[1] is object.__dict__[name]
 
 
 def identity_candidate(left: object, right: object) -> bool:
 
@@ -435,9 +435,10 @@ def run():
 def test_a_class_with_its_own_equality_pays_the_quadratic_path(benchmark):
     """A hashable class is still walked pairwise when it defines `__eq__`, and that is on purpose.
 
-    `_safe` in `_engine/_membership.py` admits a type to the hashing shortcut only if it is a known one or
-    inherits `object.__eq__`. A custom `__eq__` may disagree with the type's `__hash__`, and a set would
-    then miss a duplicate. 2001 values: no hashes at all and 1 999 001 comparisons.
+    `_agrees` in `_engine/_membership.py` admits a type whose `__eq__` and `__hash__` both come from a
+    known one, so a plain `class Money(int)` and a `StrEnum` are indexed.  This class defines both itself,
+    which is where the two may disagree and a set would miss a duplicate.  2001 values: no hashes at all
+    and 1 999 001 comparisons.
     """
     values = [_Costly(index) for index in range(2000)] + [_Costly(0)]
     _Costly.hashes = 0
 
@@ -14,6 +14,7 @@
 import dataclasses
 import datetime
 import decimal
+import enum
 import fractions
 import math
 from dataclasses import dataclass
@@ -79,8 +80,30 @@ class _NoHash:
     __hash__ = None
 
 
+class _Counted(int):
+    """A subclass that changes neither operation, so it answers exactly as `int` does."""
+
+
+class _HashesLikeText(int):
+    """One operation inherited and the other replaced, which is the disagreement the rule looks for."""
+
+    __hash__ = str.__hash__
+
+
+class _Status(str, enum.Enum):
+    """Spelled with the mixin rather than as `enum.StrEnum`, which arrived in 3.11 and this suite runs 3.10.
+
+    Identical where it matters: both take `__eq__` and `__hash__` from `str`, which is what the rule reads.
+    """
+
+    PAID = "paid"
+    DUE = "due"
+
+
 # both halves of the membership rule in one generator: values a set may answer for, and values it may
-# not.  Mixing them is what makes the properties below test the classifier rather than the fast path
+# not.  Mixing them is what makes the properties below test the classifier rather than the fast path.
+# The last three are the subclass half of it: two that a set may answer for although their exact types
+# are not on the safe list, and one that inherits equality and hashes by another rule entirely
 _MIXED_ELEMENTS = st.one_of(
     st.integers(-5, 5),
     st.text(max_size=2),
@@ -90,6 +113,9 @@ class _NoHash:
     st.builds(_ByField, st.integers(-2, 2)),
     st.builds(_NoHash),
     st.lists(st.integers(-2, 2), max_size=2),
+    st.builds(_Counted, st.integers(-2, 2)),
+    st.builds(_HashesLikeText, st.integers(-2, 2)),
+    st.sampled_from(_Status),
 )
 
 
@@ -821,6 +847,79 @@ def test_decimals_take_the_shortcut_and_answer_the_same(self):
         assert_that(values).is_subset_of(values)
         assert_that([*values, values[0]]).contains_duplicates()
 
+    def test_a_subclass_that_changes_neither_operation_takes_the_shortcut(self):
+        """The safe list holds exact types, so a subclass used to walk although it answers as its base.
+
+        `IntEnum` and `StrEnum` are the shapes a suite actually carries, a status field most of all.  Four
+        thousand of them cost 30 ms on the walk against 0.09 ms indexed, and the answer is the same either
+        way because the subclass inherits both operations unchanged.
+        """
+
+        class Money(int):
+            def __init__(self, *_: object) -> None:
+                self.currency = "USD"
+
+        class Status(str, enum.Enum):
+            PAID = "paid"
+            DUE = "due"
+
+        class Level(enum.IntEnum):
+            LOW = 1
+            HIGH = 2
+
+        for values in ([Money(index) for index in range(30)], list(Status) * 15, list(Level) * 15):
+            assert_that(_hash_safe(values)).described_as(f"{type(values[0]).__name__} is safe to index").is_true()
+            assert_that(only_faults(values, tuple(values))).is_equal_to(([], []))
+            assert_that(values).contains_only(*values)
+            assert_that(values).is_subset_of(values)
+
+        assert_that([*list(Status), Status.PAID]).contains_duplicates()
+        assert_that(_hash_safe([Level.LOW, 1, True])).described_as("mixed with the base type").is_true()
+
+    def test_a_subclass_that_replaces_one_operation_stays_on_the_walk(self):
+        """Inheriting one of the pair and redefining the other is exactly the disagreement to avoid.
+
+        Asked of the owner of each definition, so all four of these are refused: the first hashes by one
+        rule and compares by another, the second compares by its own, the third is not hashable at all
+        although its base is, and the fourth had equality assigned onto it after the class body ran.
+
+        That last one is the case the `__eq__` half of the rule exists for, and it takes a patched class
+        to build: writing `__eq__` in the body sets `__hash__` to `None` with it, so the hash half already
+        refuses those.  Patched, it keeps `int.__hash__` and answers `True` to every comparison, and a set
+        keeps two values the walk calls equal.
+        """
+
+        class HashesLikeText(int):
+            __hash__ = str.__hash__
+
+        class ComparesItsOwnWay(int):
+            def __eq__(self, other: object) -> bool:
+                return isinstance(other, ComparesItsOwnWay) and int(self) == int(other)
+
+            __hash__ = int.__hash__
+
+        class RefusesToHash(int):
+            __hash__ = None  # ty: ignore[invalid-assignment]  # the shape under test
+
+        class Patched(int):
+            pass
+
+        def _everything_is_equal(self: object, other: object) -> bool:
+            return True
+
+        Patched.__eq__ = _everything_is_equal  # ty: ignore[invalid-assignment]  # the shape under test
+
+        assert_that(Patched(1) == Patched(2)).described_as("the patched comparison").is_true()
+        assert_that({Patched(1), Patched(2)}).described_as("a set does not agree with it").is_length(2)
+
+        for kind in (HashesLikeText, ComparesItsOwnWay, RefusesToHash, Patched):
+            values = [kind(index) for index in range(30)]
+            assert_that(_hash_safe(values)).described_as(f"{kind.__name__} is not safe to index").is_false()
+
+        walked = [ComparesItsOwnWay(index) for index in range(30)]
+        assert_that(only_faults(walked, tuple(walked))).is_equal_to(([], []))
+        assert_that([*walked, walked[0]]).contains_duplicates()
+
     def test_fractions_stay_on_the_walk_and_answer_the_same(self):
         """Kept out of the shortcut for import cost, not for correctness, so both have to be shown."""
         values = [fractions.Fraction(index, 3) for index in range(30)]