python
diff --git a/‎Include/internal/pycore_opcode.h
+10-10 b/‎Include/internal/pycore_opcode.h
+10-10
diff --git a/‎Include/opcode.h
+16-17 b/‎Include/opcode.h
+16-17
diff --git a/‎Lib/opcode.py
-1 b/‎Lib/opcode.py
-1
diff --git a/‎Misc/NEWS.d/next/Core and Builtins/2023-01-04-16-40-55.gh-issue-100288.hRSRaT.rst
+2 b/‎Misc/NEWS.d/next/Core and Builtins/2023-01-04-16-40-55.gh-issue-100288.hRSRaT.rst
+2
diff --git a/‎Python/bytecodes.c
+1-28 b/‎Python/bytecodes.c
+1-28
diff --git a/‎Python/generated_cases.c.h
-27 b/‎Python/generated_cases.c.h
-27
diff --git a/‎Python/opcode_targets.h
+9-9 b/‎Python/opcode_targets.h
+9-9
diff --git a/‎Python/specialize.c
+2-3 b/‎Python/specialize.c
+2-3
@@ -336,7 +336,6 @@ def pseudo_op(name, op, real_ops):
         # These will always push [unbound method, self] onto the stack.
         "LOAD_ATTR_METHOD_LAZY_DICT",
         "LOAD_ATTR_METHOD_NO_DICT",
-        "LOAD_ATTR_METHOD_WITH_DICT",
         "LOAD_ATTR_METHOD_WITH_VALUES",
     ],
     "LOAD_CONST": [
 
@@ -0,0 +1,2 @@
+Remove the LOAD_ATTR_METHOD_WITH_DICT specialized instruction. Stats show it
+is not useful.
@@ -2605,33 +2605,6 @@ dummy_func(
             JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
         }
 
-        // error: LOAD_ATTR has irregular stack effect
-        inst(LOAD_ATTR_METHOD_WITH_DICT) {
-            /* Can be either a managed dict, or a tp_dictoffset offset.*/
-            assert(cframe.use_tracing == 0);
-            PyObject *self = TOP();
-            PyTypeObject *self_cls = Py_TYPE(self);
-            _PyLoadMethodCache *cache = (_PyLoadMethodCache *)next_instr;
-
-            DEOPT_IF(self_cls->tp_version_tag != read_u32(cache->type_version),
-                     LOAD_ATTR);
-            /* Treat index as a signed 16 bit value */
-            Py_ssize_t dictoffset = self_cls->tp_dictoffset;
-            assert(dictoffset > 0);
-            PyDictObject **dictptr = (PyDictObject**)(((char *)self)+dictoffset);
-            PyDictObject *dict = *dictptr;
-            DEOPT_IF(dict == NULL, LOAD_ATTR);
-            DEOPT_IF(dict->ma_keys->dk_version != read_u32(cache->keys_version),
-                     LOAD_ATTR);
-            STAT_INC(LOAD_ATTR, hit);
-            PyObject *res = read_obj(cache->descr);
-            assert(res != NULL);
-            assert(_PyType_HasFeature(Py_TYPE(res), Py_TPFLAGS_METHOD_DESCRIPTOR));
-            SET_TOP(Py_NewRef(res));
-            PUSH(self);
-            JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
-        }
-
         // error: LOAD_ATTR has irregular stack effect
         inst(LOAD_ATTR_METHOD_NO_DICT) {
             assert(cframe.use_tracing == 0);
@@ -3517,7 +3490,7 @@ family(load_attr) = {
     LOAD_ATTR, LOAD_ATTR_CLASS,
     LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN, LOAD_ATTR_INSTANCE_VALUE, LOAD_ATTR_MODULE,
     LOAD_ATTR_PROPERTY, LOAD_ATTR_SLOT, LOAD_ATTR_WITH_HINT,
-    LOAD_ATTR_METHOD_LAZY_DICT, LOAD_ATTR_METHOD_NO_DICT, LOAD_ATTR_METHOD_WITH_DICT,
+    LOAD_ATTR_METHOD_LAZY_DICT, LOAD_ATTR_METHOD_NO_DICT,
     LOAD_ATTR_METHOD_WITH_VALUES };
 family(load_global) = {
     LOAD_GLOBAL, LOAD_GLOBAL_BUILTIN,
 
@@ -1091,9 +1091,8 @@ PyObject *descr, DescriptorClassification kind)
             SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_HAS_MANAGED_DICT);
             goto fail;
         case OFFSET_DICT:
-            assert(owner_cls->tp_dictoffset > 0 && owner_cls->tp_dictoffset <= INT16_MAX);
-            _py_set_opcode(instr, LOAD_ATTR_METHOD_WITH_DICT);
-            break;
+            SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_NOT_MANAGED_DICT);
+            goto fail;
         case LAZY_DICT:
             assert(owner_cls->tp_dictoffset > 0 && owner_cls->tp_dictoffset <= INT16_MAX);
             _py_set_opcode(instr, LOAD_ATTR_METHOD_LAZY_DICT);
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+Remove the LOAD_ATTR_METHOD_WITH_DICT specialized instruction. Stats show it`
	`2`	`+is not useful.`