diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 9fe8ea4426f..c00cfb3b7e5 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -33,10 +33,10 @@ CLASSDEREF
 classdict
 cmpop
 codedepth
-constevaluator
 CODEUNIT
 CONIN
 CONOUT
+constevaluator
 CONVFUNC
 convparam
 copyslot
@@ -62,6 +62,7 @@ fieldlist
 fileutils
 finalbody
 finalizers
+firsttraceable
 flowgraph
 formatfloat
 freevar
diff --git a/Lib/opcode.py b/Lib/opcode.py
index 0e9520b6832..f74acf002e9 100644
--- a/Lib/opcode.py
+++ b/Lib/opcode.py
@@ -46,75 +46,6 @@
 hascompare = [opmap["COMPARE_OP"]]
 
 _cache_format = {
-    "LOAD_GLOBAL": {
-        "counter": 1,
-        "index": 1,
-        "module_keys_version": 1,
-        "builtin_keys_version": 1,
-    },
-    "BINARY_OP": {
-        "counter": 1,
-        "descr": 4,
-    },
-    "UNPACK_SEQUENCE": {
-        "counter": 1,
-    },
-    "COMPARE_OP": {
-        "counter": 1,
-    },
-    "CONTAINS_OP": {
-        "counter": 1,
-    },
-    "FOR_ITER": {
-        "counter": 1,
-    },
-    "LOAD_SUPER_ATTR": {
-        "counter": 1,
-    },
-    "LOAD_ATTR": {
-        "counter": 1,
-        "version": 2,
-        "keys_version": 2,
-        "descr": 4,
-    },
-    "STORE_ATTR": {
-        "counter": 1,
-        "version": 2,
-        "index": 1,
-    },
-    "CALL": {
-        "counter": 1,
-        "func_version": 2,
-    },
-    "CALL_KW": {
-        "counter": 1,
-        "func_version": 2,
-    },
-    "STORE_SUBSCR": {
-        "counter": 1,
-    },
-    "SEND": {
-        "counter": 1,
-    },
-    "JUMP_BACKWARD": {
-        "counter": 1,
-    },
-    "TO_BOOL": {
-        "counter": 1,
-        "version": 2,
-    },
-    "POP_JUMP_IF_TRUE": {
-        "counter": 1,
-    },
-    "POP_JUMP_IF_FALSE": {
-        "counter": 1,
-    },
-    "POP_JUMP_IF_NONE": {
-        "counter": 1,
-    },
-    "POP_JUMP_IF_NOT_NONE": {
-        "counter": 1,
-    },
 }
 
 _inline_cache_entries = {
diff --git a/Lib/test/dis_module.py b/Lib/test/dis_module.py
new file mode 100644
index 00000000000..afbf600fdee
--- /dev/null
+++ b/Lib/test/dis_module.py
@@ -0,0 +1,5 @@
+
+# A simple module for testing the dis module.
+
+def f(): pass
+def g(): pass
diff --git a/Lib/test/profilee.py b/Lib/test/profilee.py
new file mode 100644
index 00000000000..b6a090a2e34
--- /dev/null
+++ b/Lib/test/profilee.py
@@ -0,0 +1,115 @@
+"""
+Input for test_profile.py and test_cprofile.py.
+
+IMPORTANT: This stuff is touchy. If you modify anything above the
+test class you'll have to regenerate the stats by running the two
+test files.
+
+*ALL* NUMBERS in the expected output are relevant.  If you change
+the formatting of pstats, please don't just regenerate the expected
+output without checking very carefully that not a single number has
+changed.
+"""
+
+import sys
+
+# In order to have reproducible time, we simulate a timer in the global
+# variable 'TICKS', which represents simulated time in milliseconds.
+# (We can't use a helper function increment the timer since it would be
+# included in the profile and would appear to consume all the time.)
+TICKS = 42000
+
+def timer():
+    return TICKS
+
+def testfunc():
+    # 1 call
+    # 1000 ticks total: 270 ticks local, 730 ticks in subfunctions
+    global TICKS
+    TICKS += 99
+    helper()                            # 300
+    helper()                            # 300
+    TICKS += 171
+    factorial(14)                       # 130
+
+def factorial(n):
+    # 23 calls total
+    # 170 ticks total, 150 ticks local
+    # 3 primitive calls, 130, 20 and 20 ticks total
+    # including 116, 17, 17 ticks local
+    global TICKS
+    if n > 0:
+        TICKS += n
+        return mul(n, factorial(n-1))
+    else:
+        TICKS += 11
+        return 1
+
+def mul(a, b):
+    # 20 calls
+    # 1 tick, local
+    global TICKS
+    TICKS += 1
+    return a * b
+
+def helper():
+    # 2 calls
+    # 300 ticks total: 20 ticks local, 260 ticks in subfunctions
+    global TICKS
+    TICKS += 1
+    helper1()                           # 30
+    TICKS += 2
+    helper1()                           # 30
+    TICKS += 6
+    helper2()                           # 50
+    TICKS += 3
+    helper2()                           # 50
+    TICKS += 2
+    helper2()                           # 50
+    TICKS += 5
+    helper2_indirect()                  # 70
+    TICKS += 1
+
+def helper1():
+    # 4 calls
+    # 30 ticks total: 29 ticks local, 1 tick in subfunctions
+    global TICKS
+    TICKS += 10
+    hasattr(C(), "foo")                 # 1
+    TICKS += 19
+    lst = []
+    lst.append(42)                      # 0
+    sys.exception()                     # 0
+
+def helper2_indirect():
+    helper2()                           # 50
+    factorial(3)                        # 20
+
+def helper2():
+    # 8 calls
+    # 50 ticks local: 39 ticks local, 11 ticks in subfunctions
+    global TICKS
+    TICKS += 11
+    hasattr(C(), "bar")                 # 1
+    TICKS += 13
+    subhelper()                         # 10
+    TICKS += 15
+
+def subhelper():
+    # 8 calls
+    # 10 ticks total: 8 ticks local, 2 ticks in subfunctions
+    global TICKS
+    TICKS += 2
+    for i in range(2):                  # 0
+        try:
+            C().foo                     # 1 x 2
+        except AttributeError:
+            TICKS += 3                  # 3 x 2
+
+class C:
+    def __getattr__(self, name):
+        # 28 calls
+        # 1 tick, local
+        global TICKS
+        TICKS += 1
+        raise AttributeError
diff --git a/Lib/test/test_bdb.py b/Lib/test/test_bdb.py
index c41fb763a16..eb1a7710c5a 100644
--- a/Lib/test/test_bdb.py
+++ b/Lib/test/test_bdb.py
@@ -590,7 +590,6 @@ def fail(self, msg=None):
 class StateTestCase(BaseTestCase):
     """Test the step, next, return, until and quit 'set_' methods."""
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -601,7 +600,6 @@ def test_step(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step_next_on_last_statement(self):
         for set_type in ('step', 'next'):
             with self.subTest(set_type=set_type):
@@ -626,7 +624,6 @@ def test_stepinstr(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -638,7 +635,6 @@ def test_next(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_over_import(self):
         code = """
             def main():
@@ -653,7 +649,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_on_plain_statement(self):
         # Check that set_next() is equivalent to set_step() on a plain
         # statement.
@@ -666,7 +661,6 @@ def test_next_on_plain_statement(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_in_caller_frame(self):
         # Check that set_next() in the caller frame causes the tracer
         # to stop next in the caller frame.
@@ -680,7 +674,6 @@ def test_next_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),    ('step', ),
@@ -693,7 +686,6 @@ def test_return(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -705,7 +697,6 @@ def test_return_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -717,7 +708,6 @@ def test_until(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until_with_too_large_count(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),               break_in_func('tfunc_first'),
@@ -728,7 +718,6 @@ def test_until_with_too_large_count(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -740,7 +729,6 @@ def test_until_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     @patch_list(sys.meta_path)
     def test_skip(self):
         # Check that tracing is skipped over the import statement in
@@ -783,7 +771,6 @@ def test_down(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_main)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_up(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -819,7 +806,6 @@ def main():
             with TracerRun(self) as tracer:
                 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_temporary_bp(self):
         code = """
             def func():
@@ -843,7 +829,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_disabled_temporary_bp(self):
         code = """
             def func():
@@ -872,7 +857,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_condition(self):
         code = """
             def func(a):
@@ -893,7 +877,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_exception_on_condition_evaluation(self):
         code = """
             def func(a):
@@ -913,7 +896,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_ignore_count(self):
         code = """
             def func():
@@ -935,7 +917,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_ignore_count_on_disabled_bp(self):
         code = """
             def func():
@@ -963,7 +944,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_clear_two_bp_on_same_line(self):
         code = """
             def func():
@@ -1043,7 +1023,6 @@ def test_load_bps_from_previous_Bdb_instance(self):
 class RunTestCase(BaseTestCase):
     """Test run, runeval and set_trace."""
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_run_step(self):
         # Check that the bdb 'run' method stops at the first line event.
         code = """
@@ -1056,7 +1035,6 @@ def test_run_step(self):
         with TracerRun(self) as tracer:
             tracer.run(compile(textwrap.dedent(code), '<string>', 'exec'))
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_runeval_step(self):
         # Test bdb 'runeval'.
         code = """
@@ -1079,7 +1057,6 @@ def main():
 class IssuesTestCase(BaseTestCase):
     """Test fixed bdb issues."""
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step_at_return_with_no_trace_in_caller(self):
         # Issue #13183.
         # Check that the tracer does step into the caller frame when the
@@ -1248,7 +1225,6 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: All paired tuples have not been processed, the last one was number 1 [('next',)]
     def test_next_to_botframe(self):
         # gh-125422
         # Check that next command won't go to the bottom frame.
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 5f0454086d7..b469c8ab2de 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -1,5 +1,9 @@
+import contextlib
 import dis
+import io
+import itertools
 import math
+import opcode
 import os
 import unittest
 import sys
@@ -8,11 +12,18 @@
 import tempfile
 import types
 import textwrap
+import warnings
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
+
 from test import support
-from test.support import script_helper, requires_debug_ranges
+from test.support import (script_helper, requires_debug_ranges, run_code,
+                          requires_specialization)
+from test.support.bytecode_helper import instructions_with_positions
 from test.support.os_helper import FakePath
 
-
 class TestSpecifics(unittest.TestCase):
 
     def compile_single(self, source):
@@ -108,29 +119,30 @@ def __getitem__(self, key):
         exec('z = a', g, d)
         self.assertEqual(d['z'], 12)
 
+    @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
+    @support.skip_emscripten_stack_overflow()
     def test_extended_arg(self):
-        # default: 1000 * 2.5 = 2500 repetitions
-        repeat = int(sys.getrecursionlimit() * 2.5)
+        repeat = 100
         longexpr = 'x = x or ' + '-x' * repeat
         g = {}
-        code = '''
-def f(x):
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    %s
-    # the expressions above have no effect, x == argument
-    while x:
-        x -= 1
-        # EXTENDED_ARG/JUMP_ABSOLUTE here
-    return x
-''' % ((longexpr,)*10)
+        code = textwrap.dedent('''
+            def f(x):
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                %s
+                # the expressions above have no effect, x == argument
+                while x:
+                    x -= 1
+                    # EXTENDED_ARG/JUMP_ABSOLUTE here
+                return x
+            ''' % ((longexpr,)*10))
         exec(code, g)
         self.assertEqual(g['f'](5), 0)
 
@@ -146,10 +158,11 @@ def test_float_literals(self):
 
     def test_indentation(self):
         # testing compile() of indented block w/o trailing newline"
-        s = """
-if 1:
-    if 2:
-        pass"""
+        s = textwrap.dedent("""
+            if 1:
+                if 2:
+                    pass
+            """)
         compile(s, "<string>", "exec")
 
     # This test is probably specific to CPython and may not generalize
@@ -160,9 +173,8 @@ def test_leading_newlines(self):
         s256 = "".join(["\n"] * 256 + ["spam"])
         co = compile(s256, 'fn', 'exec')
         self.assertEqual(co.co_firstlineno, 1)
-        lines = list(co.co_lines())
-        self.assertEqual(lines[0][2], 0)
-        self.assertEqual(lines[1][2], 257)
+        lines = [line for _, _, line in co.co_lines()]
+        self.assertEqual(lines, [0, 257])
 
     def test_literals_with_leading_zeroes(self):
         for arg in ["077787", "0xj", "0x.", "0e",  "090000000000000",
@@ -197,8 +209,7 @@ def test_literals_with_leading_zeroes(self):
         self.assertEqual(eval("0o777"), 511)
         self.assertEqual(eval("-0o0000010"), -8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised
     def test_int_literals_too_long(self):
         n = 3000
         source = f"a = 1\nb = 2\nc = {'3'*n}\nd = 4"
@@ -272,8 +283,7 @@ def test_none_assignment(self):
             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised by compile
     def test_import(self):
         succeed = [
             'import sys',
@@ -334,8 +344,11 @@ def test_lambda_doc(self):
         l = lambda: "foo"
         self.assertIsNone(l.__doc__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_lambda_consts(self):
+        l = lambda: "this is the only const"
+        self.assertEqual(l.__code__.co_consts, ("this is the only const",))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised by compile
     def test_encoding(self):
         code = b'# -*- coding: badencoding -*-\npass\n'
         self.assertRaises(SyntaxError, compile, code, 'tmp', 'exec')
@@ -440,16 +453,134 @@ class A:
             def f():
                 __mangled = 1
                 __not_mangled__ = 2
-                import __mangled_mod
-                import __package__.module
+                import __mangled_mod       # noqa: F401
+                import __package__.module  # noqa: F401
 
         self.assertIn("_A__mangled", A.f.__code__.co_varnames)
         self.assertIn("__not_mangled__", A.f.__code__.co_varnames)
         self.assertIn("_A__mangled_mod", A.f.__code__.co_varnames)
         self.assertIn("__package__", A.f.__code__.co_varnames)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_condition_expression_with_dead_blocks_compiles(self):
+        # See gh-113054
+        compile('if (5 if 5 else T): 0', '<eval>', 'exec')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_condition_expression_with_redundant_comparisons_compiles(self):
+        # See gh-113054, gh-114083
+        exprs = [
+            'if 9<9<9and 9or 9:9',
+            'if 9<9<9and 9or 9or 9:9',
+            'if 9<9<9and 9or 9or 9or 9:9',
+            'if 9<9<9and 9or 9or 9or 9or 9:9',
+        ]
+        for expr in exprs:
+            with self.subTest(expr=expr):
+                with self.assertWarns(SyntaxWarning):
+                    compile(expr, '<eval>', 'exec')
+
+    def test_dead_code_with_except_handler_compiles(self):
+        compile(textwrap.dedent("""
+                if None:
+                    with CM:
+                        x = 1
+                else:
+                    x = 2
+               """), '<eval>', 'exec')
+
+    def test_try_except_in_while_with_chained_condition_compiles(self):
+        # see gh-124871
+        compile(textwrap.dedent("""
+            name_1, name_2, name_3 = 1, 2, 3
+            while name_3 <= name_2 > name_1:
+                try:
+                    raise
+                except:
+                    pass
+                finally:
+                    pass
+            """), '<eval>', 'exec')
+
+    def test_compile_invalid_namedexpr(self):
+        # gh-109351
+        m = ast.Module(
+            body=[
+                ast.Expr(
+                    value=ast.ListComp(
+                        elt=ast.NamedExpr(
+                            target=ast.Constant(value=1),
+                            value=ast.Constant(value=3),
+                        ),
+                        generators=[
+                            ast.comprehension(
+                                target=ast.Name(id="x", ctx=ast.Store()),
+                                iter=ast.Name(id="y", ctx=ast.Load()),
+                                ifs=[],
+                                is_async=0,
+                            )
+                        ],
+                    )
+                )
+            ],
+            type_ignores=[],
+        )
+
+        with self.assertRaisesRegex(TypeError, "NamedExpr target must be a Name"):
+            compile(ast.fix_missing_locations(m), "<file>", "exec")
+
+    def test_compile_redundant_jumps_and_nops_after_moving_cold_blocks(self):
+        # See gh-120367
+        code=textwrap.dedent("""
+            try:
+                pass
+            except:
+                pass
+            else:
+                match name_2:
+                    case b'':
+                        pass
+            finally:
+                something
+            """)
+
+        tree = ast.parse(code)
+
+        # make all instruction locations the same to create redundancies
+        for node in ast.walk(tree):
+            if hasattr(node,"lineno"):
+                 del node.lineno
+                 del node.end_lineno
+                 del node.col_offset
+                 del node.end_col_offset
+
+        compile(ast.fix_missing_locations(tree), "<file>", "exec")
+
+    def test_compile_redundant_jump_after_convert_pseudo_ops(self):
+        # See gh-120367
+        code=textwrap.dedent("""
+            if name_2:
+                pass
+            else:
+                try:
+                    pass
+                except:
+                    pass
+            ~name_5
+            """)
+
+        tree = ast.parse(code)
+
+        # make all instruction locations the same to create redundancies
+        for node in ast.walk(tree):
+            if hasattr(node,"lineno"):
+                 del node.lineno
+                 del node.end_lineno
+                 del node.col_offset
+                 del node.end_col_offset
+
+        compile(ast.fix_missing_locations(tree), "<file>", "exec")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: <code object <module> at 0xb77555080 file "<assign>1", line 1> != <code object <module> at 0xb77554f00 file "<assign>3", line 1>
     def test_compile_ast(self):
         fname = __file__
         if fname.lower().endswith('pyc'):
@@ -478,13 +609,33 @@ def test_compile_ast(self):
         self.assertRaises(TypeError, compile, co1, '<ast>', 'eval')
 
         # raise exception when node type is no start node
-        self.assertRaises(TypeError, compile, _ast.If(), '<ast>', 'exec')
+        self.assertRaises(TypeError, compile, _ast.If(test=_ast.Name(id='x', ctx=_ast.Load())), '<ast>', 'exec')
 
         # raise exception when node has invalid children
         ast = _ast.Module()
-        ast.body = [_ast.BoolOp()]
+        ast.body = [_ast.BoolOp(op=_ast.Or())]
         self.assertRaises(TypeError, compile, ast, '<ast>', 'exec')
 
+    def test_compile_invalid_typealias(self):
+        # gh-109341
+        m = ast.Module(
+            body=[
+                ast.TypeAlias(
+                    name=ast.Subscript(
+                        value=ast.Name(id="foo", ctx=ast.Load()),
+                        slice=ast.Constant(value="x"),
+                        ctx=ast.Store(),
+                    ),
+                    type_params=[],
+                    value=ast.Name(id="Callable", ctx=ast.Load()),
+                )
+            ],
+            type_ignores=[],
+        )
+
+        with self.assertRaisesRegex(TypeError, "TypeAlias with non-Name name"):
+            compile(ast.fix_missing_locations(m), "<file>", "exec")
+
     def test_dict_evaluation_order(self):
         i = 0
 
@@ -496,18 +647,32 @@ def f():
         d = {f(): f(), f(): f()}
         self.assertEqual(d, {1: 2, 3: 4})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: TypeError not raised
     def test_compile_filename(self):
         for filename in 'file.py', b'file.py':
             code = compile('pass', filename, 'exec')
             self.assertEqual(code.co_filename, 'file.py')
         for filename in bytearray(b'file.py'), memoryview(b'file.py'):
-            with self.assertWarns(DeprecationWarning):
-                code = compile('pass', filename, 'exec')
-            self.assertEqual(code.co_filename, 'file.py')
+            with self.assertRaises(TypeError):
+                compile('pass', filename, 'exec')
         self.assertRaises(TypeError, compile, 'pass', list(b'file.py'), 'exec')
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; TypeError: Expected type bool, not EvilBool
+    def test_compile_filename_refleak(self):
+        # Regression tests for reference leak in PyUnicode_FSDecoder.
+        # See https://github.com/python/cpython/issues/139748.
+        mortal_str = 'this is a mortal string'
+        # check error path when 'mode' AC conversion failed
+        self.assertRaises(TypeError, compile, b'', mortal_str, mode=1234)
+        # check error path when 'optimize' AC conversion failed
+        self.assertRaises(OverflowError, compile, b'', mortal_str,
+                          'exec', optimize=1 << 1000)
+        # check error path when 'dont_inherit' AC conversion failed
+        class EvilBool:
+            def __bool__(self): raise ValueError
+        self.assertRaises(ValueError, compile, b'', mortal_str,
+                          'exec', dont_inherit=EvilBool())
+
     @support.cpython_only
     def test_same_filename_used(self):
         s = """def f(): pass\ndef g(): pass"""
@@ -533,8 +698,7 @@ def test_single_statement(self):
         self.compile_single("class T:\n   pass")
         self.compile_single("c = '''\na=1\nb=2\nc=3\n'''")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: SyntaxError not raised by compile_single
     def test_bad_single_statement(self):
         self.assertInvalidSingle('1\n2')
         self.assertInvalidSingle('def f(): pass')
@@ -546,8 +710,7 @@ def test_bad_single_statement(self):
         self.assertInvalidSingle('x = 5 # comment\nx = 6\n')
         self.assertInvalidSingle("c = '''\nd=1\n'''\na = 1\n\nb = 2\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: b'source code cannot contain null bytes' not found in b'OSError: stream did not contain valid UTF-8\n'
     def test_particularly_evil_undecodable(self):
         # Issue 24022
         src = b'0000\x00\n00000000000\n\x00\n\x9e\n'
@@ -556,10 +719,9 @@ def test_particularly_evil_undecodable(self):
             with open(fn, "wb") as fp:
                 fp.write(src)
             res = script_helper.run_python_until_end(fn)[0]
-        self.assertIn(b"Non-UTF-8", res.err)
+        self.assertIn(b"source code cannot contain null bytes", res.err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: b'source code cannot contain null bytes' not found in b'OSError: stream did not contain valid UTF-8\n'
     def test_yet_more_evil_still_undecodable(self):
         # Issue #25388
         src = b"#\x00\n#\xfd\n"
@@ -568,30 +730,25 @@ def test_yet_more_evil_still_undecodable(self):
             with open(fn, "wb") as fp:
                 fp.write(src)
             res = script_helper.run_python_until_end(fn)[0]
-        self.assertIn(b"Non-UTF-8", res.err)
+        self.assertIn(b"source code cannot contain null bytes", res.err)
 
     @support.cpython_only
+    @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
+    @support.skip_emscripten_stack_overflow()
     def test_compiler_recursion_limit(self):
-        # Expected limit is sys.getrecursionlimit() * the scaling factor
-        # in symtable.c (currently 3)
-        # We expect to fail *at* that limit, because we use up some of
-        # the stack depth limit in the test suite code
-        # So we check the expected limit and 75% of that
-        # XXX (ncoghlan): duplicating the scaling factor here is a little
-        # ugly. Perhaps it should be exposed somewhere...
-        fail_depth = sys.getrecursionlimit() * 3
-        crash_depth = sys.getrecursionlimit() * 300
-        success_depth = int(fail_depth * 0.75)
+        # Compiler frames are small
+        limit = 100
+        # Android test devices have less memory.
+        crash_depth = limit * (1000 if sys.platform == "android" else 5000)
+        success_depth = limit
 
         def check_limit(prefix, repeated, mode="single"):
             expect_ok = prefix + repeated * success_depth
             compile(expect_ok, '<test>', mode)
-            for depth in (fail_depth, crash_depth):
-                broken = prefix + repeated * depth
-                details = "Compiling ({!r} + {!r} * {})".format(
-                            prefix, repeated, depth)
-                with self.assertRaises(RecursionError, msg=details):
-                    compile(broken, '<test>', mode)
+            broken = prefix + repeated * crash_depth
+            details = f"Compiling ({prefix!r} + {repeated!r} * {crash_depth})"
+            with self.assertRaises(RecursionError, msg=details):
+                compile(broken, '<test>', mode)
 
         check_limit("a", "()")
         check_limit("a", ".b")
@@ -601,14 +758,13 @@ def check_limit(prefix, repeated, mode="single"):
         # check_limit("a", " if a else a")
         # check_limit("if a: pass", "\nelif a: pass", mode="exec")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: "cannot contain null" does not match "invalid syntax (<dummy>, line 1)"
     def test_null_terminated(self):
         # The source code is null-terminated internally, but bytes-like
         # objects are accepted, which could be not terminated.
-        with self.assertRaisesRegex(ValueError, "cannot contain null"):
+        with self.assertRaisesRegex(SyntaxError, "cannot contain null"):
             compile("123\x00", "<dummy>", "eval")
-        with self.assertRaisesRegex(ValueError, "cannot contain null"):
+        with self.assertRaisesRegex(SyntaxError, "cannot contain null"):
             compile(memoryview(b"123\x00"), "<dummy>", "eval")
         code = compile(memoryview(b"123\x00")[1:-1], "<dummy>", "eval")
         self.assertEqual(eval(code), 23)
@@ -649,7 +805,6 @@ def check_same_constant(const):
             self.assertEqual(repr(f1()), repr(const))
 
         check_same_constant(None)
-        check_same_constant(0)
         check_same_constant(0.0)
         check_same_constant(b'abc')
         check_same_constant('abc')
@@ -664,7 +819,7 @@ def check_same_constant(const):
         # Merge constants in tuple or frozenset
         f1, f2 = lambda: "not a name", lambda: ("not a name",)
         f3 = lambda x: x in {("not a name",)}
-        self.assertIs(f1.__code__.co_consts[1],
+        self.assertIs(f1.__code__.co_consts[0],
                       f2.__code__.co_consts[1][0])
         self.assertIs(next(iter(f3.__code__.co_consts[1])),
                       f2.__code__.co_consts[1])
@@ -686,16 +841,62 @@ def test_merge_code_attrs(self):
 
         self.assertIs(f1.__code__.co_linetable, f2.__code__.co_linetable)
 
+    @support.cpython_only
+    def test_remove_unused_consts(self):
+        def f():
+            "docstring"
+            if True:
+                return "used"
+            else:
+                return "unused"
+
+        self.assertEqual(f.__code__.co_consts,
+                         (f.__doc__, "used"))
+
+    @support.cpython_only
+    def test_remove_unused_consts_no_docstring(self):
+        # the first item (None for no docstring in this case) is
+        # always retained.
+        def f():
+            if True:
+                return "used"
+            else:
+                return "unused"
+
+        self.assertEqual(f.__code__.co_consts,
+                         (True, "used"))
+
+    @support.cpython_only
+    def test_remove_unused_consts_extended_args(self):
+        N = 1000
+        code = ["def f():\n"]
+        code.append("\ts = ''\n")
+        code.append("\tfor i in range(1):\n")
+        for i in range(N):
+            code.append(f"\t\tif True: s += 't{i}'\n")
+            code.append(f"\t\tif False: s += 'f{i}'\n")
+        code.append("\treturn s\n")
+
+        code = "".join(code)
+        g = {}
+        eval(compile(code, "file.py", "exec"), g)
+        exec(code, g)
+        f = g['f']
+        expected = tuple([''] + [f't{i}' for i in range(N)])
+        self.assertEqual(f.__code__.co_consts, expected)
+        expected = "".join(expected[1:])
+        self.assertEqual(expected, f())
+
     # Stripping unused constants is not a strict requirement for the
     # Python semantics, it's a more an implementation detail.
     @support.cpython_only
-    def test_strip_unused_consts(self):
+    def test_strip_unused_None(self):
         # Python 3.10rc1 appended None to co_consts when None is not used
         # at all. See bpo-45056.
         def f1():
             "docstring"
             return 42
-        self.assertEqual(f1.__code__.co_consts, ("docstring", 42))
+        self.assertEqual(f1.__code__.co_consts, (f1.__doc__,))
 
     # This is a regression test for a CPython specific peephole optimizer
     # implementation bug present in a few releases.  It's assertion verifies
@@ -715,8 +916,90 @@ def unused_code_at_end():
             'RETURN_VALUE',
             list(dis.get_instructions(unused_code_at_end))[-1].opname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.cpython_only
+    def test_docstring(self):
+        src = textwrap.dedent("""
+            def with_docstring():
+                "docstring"
+
+            def two_strings():
+                "docstring"
+                "not docstring"
+
+            def with_fstring():
+                f"not docstring"
+
+            def with_const_expression():
+                "also" + " not docstring"
+
+            def multiple_const_strings():
+                "not docstring " * 3
+            """)
+
+        for opt in [0, 1, 2]:
+            with self.subTest(opt=opt):
+                code = compile(src, "<test>", "exec", optimize=opt)
+                ns = {}
+                exec(code, ns)
+
+                if opt < 2:
+                    self.assertEqual(ns['with_docstring'].__doc__, "docstring")
+                    self.assertEqual(ns['two_strings'].__doc__, "docstring")
+                else:
+                    self.assertIsNone(ns['with_docstring'].__doc__)
+                    self.assertIsNone(ns['two_strings'].__doc__)
+                self.assertIsNone(ns['with_fstring'].__doc__)
+                self.assertIsNone(ns['with_const_expression'].__doc__)
+                self.assertIsNone(ns['multiple_const_strings'].__doc__)
+
+    @support.cpython_only
+    def test_docstring_interactive_mode(self):
+        srcs = [
+            """def with_docstring():
+                "docstring"
+            """,
+            """class with_docstring:
+                "docstring"
+            """,
+        ]
+
+        for opt in [0, 1, 2]:
+            for src in srcs:
+                with self.subTest(opt=opt, src=src):
+                    code = compile(textwrap.dedent(src), "<test>", "single", optimize=opt)
+                    ns = {}
+                    exec(code, ns)
+                    if opt < 2:
+                        self.assertEqual(ns['with_docstring'].__doc__, "docstring")
+                    else:
+                        self.assertIsNone(ns['with_docstring'].__doc__)
+
+    @support.cpython_only
+    def test_docstring_omitted(self):
+        # See gh-115347
+        src = textwrap.dedent("""
+            def f():
+                "docstring1"
+                def h():
+                    "docstring2"
+                    return 42
+
+                class C:
+                    "docstring3"
+                    pass
+
+                return h
+        """)
+        for opt in [-1, 0, 1, 2]:
+            for mode in ["exec", "single"]:
+                with self.subTest(opt=opt, mode=mode):
+                    code = compile(src, "<test>", mode, optimize=opt)
+                    output = io.StringIO()
+                    with contextlib.redirect_stdout(output):
+                        dis.dis(code)
+                    self.assertNotIn('NOP', output.getvalue())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: unable to find constant -0.0 in (0.0,)
     def test_dont_merge_constants(self):
         # Issue #25843: compile() must not merge constants which are equal
         # but have a different type.
@@ -733,7 +1016,6 @@ def check_different_constants(const1, const2):
             self.assertEqual(repr(f1()), repr(const1))
             self.assertEqual(repr(f2()), repr(const2))
 
-        check_different_constants(0, 0.0)
         check_different_constants(+0.0, -0.0)
         check_different_constants((0,), (0.0,))
         check_different_constants('a', b'a')
@@ -761,10 +1043,13 @@ def test_path_like_objects(self):
         # An implicit test for PyUnicode_FSDecoder().
         compile("42", FakePath("test_compile_pathlike"), "single")
 
+    # bpo-31113: Stack overflow when compile a long sequence of
+    # complex statements.
+    @support.requires_resource('cpu')
     def test_stack_overflow(self):
-        # bpo-31113: Stack overflow when compile a long sequence of
-        # complex statements.
-        compile("if a: b\n" * 200000, "<dummy>", "exec")
+        # Android test devices have less memory.
+        size = 100_000 if sys.platform == "android" else 200_000
+        compile("if a: b\n" * size, "<dummy>", "exec")
 
     # Multiple users rely on the fact that CPython does not generate
     # bytecode for dead code blocks. See bpo-37500 for more context.
@@ -796,12 +1081,10 @@ def unused_block_while_else():
         for func in funcs:
             opcodes = list(dis.get_instructions(func))
             self.assertLessEqual(len(opcodes), 4)
-            self.assertEqual('LOAD_CONST', opcodes[-2].opname)
-            self.assertEqual(None, opcodes[-2].argval)
             self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
+            self.assertEqual(None, opcodes[-1].argval)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 3 != 8
     def test_false_while_loop(self):
         def break_in_while():
             while False:
@@ -817,12 +1100,10 @@ def continue_in_while():
         for func in funcs:
             opcodes = list(dis.get_instructions(func))
             self.assertEqual(3, len(opcodes))
-            self.assertEqual('LOAD_CONST', opcodes[1].opname)
+            self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
             self.assertEqual(None, opcodes[1].argval)
-            self.assertEqual('RETURN_VALUE', opcodes[2].opname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_consts_in_conditionals(self):
         def and_true(x):
             return True and x
@@ -846,8 +1127,6 @@ def or_false(x):
                 self.assertIn('LOAD_', opcodes[-2].opname)
                 self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_imported_load_method(self):
         sources = [
             """\
@@ -880,7 +1159,33 @@ def foo(x):
                 instructions = [opcode.opname for opcode in opcodes]
                 self.assertNotIn('LOAD_METHOD', instructions)
                 self.assertIn('LOAD_ATTR', instructions)
-                self.assertIn('PRECALL', instructions)
+                self.assertIn('CALL', instructions)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'LOAD_SMALL_INT' not found in ['RESUME', 'LOAD_CONST', 'RETURN_VALUE']
+    def test_folding_type_param(self):
+        get_code_fn_cls = lambda x: x.co_consts[0].co_consts[2]
+        get_code_type_alias = lambda x: x.co_consts[0].co_consts[3]
+        snippets = [
+            ("def foo[T = 40 + 5](): pass", get_code_fn_cls),
+            ("def foo[**P = 40 + 5](): pass", get_code_fn_cls),
+            ("def foo[*Ts = 40 + 5](): pass", get_code_fn_cls),
+            ("class foo[T = 40 + 5]: pass", get_code_fn_cls),
+            ("class foo[**P = 40 + 5]: pass", get_code_fn_cls),
+            ("class foo[*Ts = 40 + 5]: pass", get_code_fn_cls),
+            ("type foo[T = 40 + 5] = 1", get_code_type_alias),
+            ("type foo[**P = 40 + 5] = 1", get_code_type_alias),
+            ("type foo[*Ts = 40 + 5] = 1", get_code_type_alias),
+        ]
+        for snippet, get_code in snippets:
+            c = compile(snippet, "<dummy>", "exec")
+            code = get_code(c)
+            opcodes = list(dis.get_instructions(code))
+            instructions = [opcode.opname for opcode in opcodes]
+            args = [opcode.oparg for opcode in opcodes]
+            self.assertNotIn(40, args)
+            self.assertNotIn(5, args)
+            self.assertIn('LOAD_SMALL_INT', instructions)
+            self.assertIn(45, args)
 
     def test_lineno_procedure_call(self):
         def call():
@@ -890,8 +1195,7 @@ def call():
         line1 = call.__code__.co_firstlineno + 1
         assert line1 not in [line for (_, _, line) in call.__code__.co_lines()]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_lineno_after_implicit_return(self):
         TRUE = True
         # Don't use constant True or False, as compiler will remove test
@@ -935,10 +1239,12 @@ def no_code2():
 
         for func in (no_code1, no_code2):
             with self.subTest(func=func):
+                if func is no_code1 and no_code1.__doc__ is None:
+                    continue
                 code = func.__code__
-                lines = list(code.co_lines())
-                start, end, line = lines[0]
+                [(start, end, line)] = code.co_lines()
                 self.assertEqual(start, 0)
+                self.assertEqual(end, len(code.co_code))
                 self.assertEqual(line, code.co_firstlineno)
 
     def get_code_lines(self, code):
@@ -950,8 +1256,7 @@ def get_code_lines(self, code):
                 last_line = line
         return res
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_lineno_attribute(self):
         def load_attr():
             return (
@@ -996,8 +1301,7 @@ def aug_store_attr():
                 code_lines = self.get_code_lines(func.__code__)
                 self.assertEqual(lines, code_lines)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + [0]
     def test_line_number_genexp(self):
 
         def return_genexp():
@@ -1006,14 +1310,12 @@ def return_genexp():
                     x
                     in
                     y)
-        genexp_lines = [0, 2, 0]
+        genexp_lines = [0, 4, 2, 0, 4]
 
-        genexp_code = return_genexp.__code__.co_consts[1]
+        genexp_code = return_genexp.__code__.co_consts[0]
         code_lines = self.get_code_lines(genexp_code)
         self.assertEqual(genexp_lines, code_lines)
 
-    # TODO: RUSTPYTHON; implicit return line number after async for
-    @unittest.expectedFailure
     def test_line_number_implicit_return_after_async_for(self):
 
         async def test(aseq):
@@ -1024,6 +1326,73 @@ async def test(aseq):
         code_lines = self.get_code_lines(test.__code__)
         self.assertEqual(expected_lines, code_lines)
 
+    def check_line_numbers(self, code, opnames=None):
+        # Check that all instructions whose op matches opnames
+        # have a line number. opnames can be a single name, or
+        # a sequence of names. If it is None, match all ops.
+
+        if isinstance(opnames, str):
+            opnames = (opnames, )
+        for inst in dis.Bytecode(code):
+            if opnames and inst.opname in opnames:
+                self.assertIsNotNone(inst.positions.lineno)
+
+    def test_line_number_synthetic_jump_multiple_predecessors(self):
+        def f():
+            for x in it:
+                try:
+                    if C1:
+                        yield 2
+                except OSError:
+                    pass
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
+    def test_line_number_synthetic_jump_multiple_predecessors_nested(self):
+        def f():
+            for x in it:
+                try:
+                    X = 3
+                except OSError:
+                    try:
+                        if C3:
+                            X = 4
+                    except OSError:
+                        pass
+            return 42
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
+    def test_line_number_synthetic_jump_multiple_predecessors_more_nested(self):
+        def f():
+            for x in it:
+                try:
+                    X = 3
+                except OSError:
+                    try:
+                        if C3:
+                            if C4:
+                                X = 4
+                    except OSError:
+                        try:
+                            if C3:
+                                if C4:
+                                    X = 5
+                        except OSError:
+                            pass
+            return 42
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
+    def test_lineno_of_backward_jump_conditional_in_loop(self):
+        # Issue gh-107901
+        def f():
+            for i in x:
+                if y:
+                    pass
+
+        self.check_line_numbers(f.__code__, 'JUMP_BACKWARD')
+
     def test_big_dict_literal(self):
         # The compiler has a flushing point in "compiler_dict" that calls compiles
         # a portion of the dictionary literal when the loop that iterates over the items
@@ -1073,14 +1442,109 @@ def while_not_chained(a, b, c):
         for instr in dis.Bytecode(while_not_chained):
             self.assertNotEqual(instr.opname, "EXTENDED_ARG")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.cpython_only
+    def test_uses_slice_instructions(self):
+
+        def check_op_count(func, op, expected):
+            actual = 0
+            for instr in dis.Bytecode(func):
+                if instr.opname == op:
+                    actual += 1
+            self.assertEqual(actual, expected)
+
+        def check_consts(func, typ, expected):
+            expected = set([repr(x) for x in expected])
+            all_consts = set()
+            consts = func.__code__.co_consts
+            for instr in dis.Bytecode(func):
+                if instr.opname == "LOAD_CONST" and isinstance(consts[instr.oparg], typ):
+                    all_consts.add(repr(consts[instr.oparg]))
+            self.assertEqual(all_consts, expected)
+
+        def load():
+            return x[a:b] + x [a:] + x[:b] + x[:]
+
+        check_op_count(load, "BINARY_SLICE", 3)
+        check_op_count(load, "BUILD_SLICE", 0)
+        check_consts(load, slice, [slice(None, None, None)])
+        check_op_count(load, "BINARY_OP", 4)
+
+        def store():
+            x[a:b] = y
+            x [a:] = y
+            x[:b] = y
+            x[:] = y
+
+        check_op_count(store, "STORE_SLICE", 3)
+        check_op_count(store, "BUILD_SLICE", 0)
+        check_op_count(store, "STORE_SUBSCR", 1)
+        check_consts(store, slice, [slice(None, None, None)])
+
+        def long_slice():
+            return x[a:b:c]
+
+        check_op_count(long_slice, "BUILD_SLICE", 1)
+        check_op_count(long_slice, "BINARY_SLICE", 0)
+        check_consts(long_slice, slice, [])
+        check_op_count(long_slice, "BINARY_OP", 1)
+
+        def aug():
+            x[a:b] += y
+
+        check_op_count(aug, "BINARY_SLICE", 1)
+        check_op_count(aug, "STORE_SLICE", 1)
+        check_op_count(aug, "BUILD_SLICE", 0)
+        check_op_count(aug, "BINARY_OP", 1)
+        check_op_count(aug, "STORE_SUBSCR", 0)
+        check_consts(aug, slice, [])
+
+        def aug_const():
+            x[1:2] += y
+
+        check_op_count(aug_const, "BINARY_SLICE", 0)
+        check_op_count(aug_const, "STORE_SLICE", 0)
+        check_op_count(aug_const, "BINARY_OP", 2)
+        check_op_count(aug_const, "STORE_SUBSCR", 1)
+        check_consts(aug_const, slice, [slice(1, 2)])
+
+        def compound_const_slice():
+            x[1:2:3, 4:5:6] = y
+
+        check_op_count(compound_const_slice, "BINARY_SLICE", 0)
+        check_op_count(compound_const_slice, "BUILD_SLICE", 0)
+        check_op_count(compound_const_slice, "STORE_SLICE", 0)
+        check_op_count(compound_const_slice, "STORE_SUBSCR", 1)
+        check_consts(compound_const_slice, slice, [])
+        check_consts(compound_const_slice, tuple, [(slice(1, 2, 3), slice(4, 5, 6))])
+
+        def mutable_slice():
+            x[[]:] = y
+
+        check_consts(mutable_slice, slice, {})
+
+        def different_but_equal():
+            x[:0] = y
+            x[:0.0] = y
+            x[:False] = y
+            x[:None] = y
+
+        check_consts(
+            different_but_equal,
+            slice,
+            [
+                slice(None, 0, None),
+                slice(None, 0.0, None),
+                slice(None, False, None),
+                slice(None, None, None)
+            ]
+        )
+
     def test_compare_positions(self):
-        for opname, op in [
-            ("COMPARE_OP", "<"),
-            ("COMPARE_OP", "<="),
-            ("COMPARE_OP", ">"),
-            ("COMPARE_OP", ">="),
+        for opname_prefix, op in [
+            ("COMPARE_", "<"),
+            ("COMPARE_", "<="),
+            ("COMPARE_", ">"),
+            ("COMPARE_", ">="),
             ("CONTAINS_OP", "in"),
             ("CONTAINS_OP", "not in"),
             ("IS_OP", "is"),
@@ -1095,11 +1559,313 @@ def test_compare_positions(self):
                 actual_positions = [
                     instruction.positions
                     for instruction in dis.get_instructions(code)
-                    if instruction.opname == opname
+                    if instruction.opname.startswith(opname_prefix)
                 ]
                 with self.subTest(source):
                     self.assertEqual(actual_positions, expected_positions)
 
+    def test_if_expression_expression_empty_block(self):
+        # See regression in gh-99708
+        exprs = [
+            "assert (False if 1 else True)",
+            "def f():\n\tif not (False if 1 else True): raise AssertionError",
+            "def f():\n\tif not (False if 1 else True): return 12",
+        ]
+        for expr in exprs:
+            with self.subTest(expr=expr):
+                compile(expr, "<single>", "exec")
+
+    def test_multi_line_lambda_as_argument(self):
+        # See gh-101928
+        code = textwrap.dedent("""
+            def foo(param, lambda_exp):
+                pass
+
+            foo(param=0,
+                lambda_exp=lambda:
+                1)
+        """)
+        compile(code, "<test>", "exec")
+
+    def test_apply_static_swaps(self):
+        def f(x, y):
+            a, a = x, y
+            return a
+        self.assertEqual(f("x", "y"), "y")
+
+    def test_apply_static_swaps_2(self):
+        def f(x, y, z):
+            a, b, a = x, y, z
+            return a
+        self.assertEqual(f("x", "y", "z"), "z")
+
+    def test_apply_static_swaps_3(self):
+        def f(x, y, z):
+            a, a, b = x, y, z
+            return a
+        self.assertEqual(f("x", "y", "z"), "y")
+
+    def test_variable_dependent(self):
+        # gh-104635: Since the value of b is dependent on the value of a
+        # the first STORE_FAST for a should not be skipped. (e.g POP_TOP).
+        # This test case is added to prevent potential regression from aggressive optimization.
+        def f():
+            a = 42; b = a + 54; a = 54
+            return a, b
+        self.assertEqual(f(), (54, 96))
+
+    def test_duplicated_small_exit_block(self):
+        # See gh-109627
+        def f():
+            while element and something:
+                try:
+                    return something
+                except:
+                    pass
+
+    def test_cold_block_moved_to_end(self):
+        # See gh-109719
+        def f():
+            while name:
+                try:
+                    break
+                except:
+                    pass
+            else:
+                1 if 1 else 1
+
+    def test_remove_empty_basic_block_with_jump_target_label(self):
+        # See gh-109823
+        def f(x):
+            while x:
+                0 if 1 else 0
+
+    def test_remove_redundant_nop_edge_case(self):
+        # See gh-109889
+        def f():
+            a if (1 if b else c) else d
+
+    def test_global_declaration_in_except_used_in_else(self):
+        # See gh-111123
+        code = textwrap.dedent("""\
+            def f():
+                try:
+                    pass
+                %s Exception:
+                    global a
+                else:
+                    print(a)
+        """)
+
+        g, l = {'a': 5}, {}
+        for kw in ("except", "except*"):
+            exec(code % kw, g, l);
+
+    def test_regression_gh_120225(self):
+        async def name_4():
+            match b'':
+                case True:
+                    pass
+                case name_5 if f'e':
+                    {name_3: name_4 async for name_2 in name_5}
+                case []:
+                    pass
+            [[]]
+
+    def test_globals_dict_subclass(self):
+        # gh-132386
+        class WeirdDict(dict):
+            pass
+
+        ns = {}
+        exec('def foo(): return a', WeirdDict(), ns)
+
+        self.assertRaises(NameError, ns['foo'])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + [3, 5, 3, 5]
+    def test_compile_warnings(self):
+        # Each invocation of compile() emits compiler warnings, even if they
+        # have the same message and line number.
+        source = textwrap.dedent(r"""
+            # tokenizer
+            1or 0  # line 3
+            # code generator
+            1 is 1  # line 5
+        """)
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("default")
+            for i in range(2):
+                # Even if compile() is at the same line.
+                compile(source, '<stdin>', 'exec')
+
+        self.assertEqual([wm.lineno for wm in caught], [3, 5] * 2)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + [5, 9]
+    def test_compile_warning_in_finally(self):
+        # Ensure that warnings inside finally blocks are
+        # only emitted once despite the block being
+        # compiled twice (for normal execution and for
+        # exception handling).
+        source = textwrap.dedent("""
+            try:
+                pass
+            finally:
+                1 is 1  # line 5
+                try:
+                    pass
+                finally: # nested
+                    1 is 1  # line 9
+        """)
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            compile(source, '<stdin>', 'exec')
+
+        self.assertEqual(sorted(wm.lineno for wm in caught), [5, 9])
+        for wm in caught:
+            self.assertEqual(wm.category, SyntaxWarning)
+            self.assertIn("\"is\" with 'int' literal", str(wm.message))
+
+        # Other code path is used for "try" with "except*".
+        source = textwrap.dedent("""
+            try:
+                pass
+            except *Exception:
+                pass
+            finally:
+                1 is 1  # line 7
+                try:
+                    pass
+                except *Exception:
+                    pass
+                finally: # nested
+                    1 is 1  # line 13
+        """)
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            compile(source, '<stdin>', 'exec')
+
+        self.assertEqual(sorted(wm.lineno for wm in caught), [7, 13])
+        for wm in caught:
+            self.assertEqual(wm.category, SyntaxWarning)
+            self.assertIn("\"is\" with 'int' literal", str(wm.message))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @support.subTests('src', [
+        textwrap.dedent("""
+            def f():
+                try:
+                    pass
+                finally:
+                    return 42
+            """),
+        textwrap.dedent("""
+            for x in y:
+                try:
+                    pass
+                finally:
+                    break
+            """),
+        textwrap.dedent("""
+            for x in y:
+                try:
+                    pass
+                finally:
+                    continue
+            """),
+    ])
+    def test_pep_765_warnings(self, src):
+        with self.assertWarnsRegex(SyntaxWarning, 'finally'):
+            compile(src, '<string>', 'exec')
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            tree = ast.parse(src)
+        with self.assertWarnsRegex(SyntaxWarning, 'finally'):
+            compile(tree, '<string>', 'exec')
+
+    @support.subTests('src', [
+        textwrap.dedent("""
+            try:
+                pass
+            finally:
+                def f():
+                    return 42
+            """),
+        textwrap.dedent("""
+            try:
+                pass
+            finally:
+                for x in y:
+                    break
+            """),
+        textwrap.dedent("""
+            try:
+                pass
+            finally:
+                for x in y:
+                    continue
+            """),
+    ])
+    def test_pep_765_no_warnings(self, src):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            compile(src, '<string>', 'exec')
+
+
+class TestBooleanExpression(unittest.TestCase):
+    class Value:
+        def __init__(self):
+            self.called = 0
+
+        def __bool__(self):
+            self.called += 1
+            return self.value
+
+    class Yes(Value):
+        value = True
+
+    class No(Value):
+        value = False
+
+    def test_short_circuit_and(self):
+        v = [self.Yes(), self.No(), self.Yes()]
+        res = v[0] and v[1] and v[0]
+        self.assertIs(res, v[1])
+        self.assertEqual([e.called for e in v], [1, 1, 0])
+
+    def test_short_circuit_or(self):
+        v = [self.No(), self.Yes(), self.No()]
+        res = v[0] or v[1] or v[0]
+        self.assertIs(res, v[1])
+        self.assertEqual([e.called for e in v], [1, 1, 0])
+
+    def test_compound(self):
+        # See gh-124285
+        v = [self.No(), self.Yes(), self.Yes(), self.Yes()]
+        res = v[0] and v[1] or v[2] or v[3]
+        self.assertIs(res, v[2])
+        self.assertEqual([e.called for e in v], [1, 0, 1, 0])
+
+        v = [self.No(), self.No(), self.Yes(), self.Yes(), self.No()]
+        res = v[0] or v[1] and v[2] or v[3] or v[4]
+        self.assertIs(res, v[3])
+        self.assertEqual([e.called for e in v], [1, 1, 0, 1, 0])
+
+    def test_exception(self):
+        # See gh-137288
+        class Foo:
+            def __bool__(self):
+                raise NotImplementedError()
+
+        a = Foo()
+        b = Foo()
+
+        with self.assertRaises(NotImplementedError):
+            bool(a)
+
+        with self.assertRaises(NotImplementedError):
+            c = a or b
 
 @requires_debug_ranges()
 class TestSourcePositions(unittest.TestCase):
@@ -1118,7 +1884,7 @@ def check_positions_against_ast(self, snippet):
         class SourceOffsetVisitor(ast.NodeVisitor):
             def generic_visit(self, node):
                 super().generic_visit(node)
-                if not isinstance(node, ast.expr) and not isinstance(node, ast.stmt):
+                if not isinstance(node, (ast.expr, ast.stmt, ast.pattern)):
                     return
                 lines.add(node.lineno)
                 end_lines.add(node.end_lineno)
@@ -1147,8 +1913,8 @@ def generic_visit(self, node):
     def assertOpcodeSourcePositionIs(self, code, opcode,
             line, end_line, column, end_column, occurrence=1):
 
-        for instr, position in zip(
-            dis.Bytecode(code, show_caches=True), code.co_positions(), strict=True
+        for instr, position in instructions_with_positions(
+            dis.Bytecode(code), code.co_positions()
         ):
             if instr.opname == opcode:
                 occurrence -= 1
@@ -1186,15 +1952,303 @@ def test_compiles_to_extended_op_arg(self):
             column=2, end_column=9, occurrence=2)
 
     def test_multiline_expression(self):
-        snippet = """\
-f(
-    1, 2, 3, 4
-)
-"""
+        snippet = textwrap.dedent("""\
+            f(
+                1, 2, 3, 4
+            )
+            """)
         compiled_code, _ = self.check_positions_against_ast(snippet)
         self.assertOpcodeSourcePositionIs(compiled_code, 'CALL',
             line=1, end_line=3, column=0, end_column=1)
 
+    @requires_specialization
+    def test_multiline_boolean_expression(self):
+        snippet = textwrap.dedent("""\
+            if (a or
+                (b and not c) or
+                not (
+                    d > 0)):
+                x = 42
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        # jump if a is true:
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_TRUE',
+            line=1, end_line=1, column=4, end_column=5, occurrence=1)
+        # jump if b is false:
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_FALSE',
+            line=2, end_line=2, column=5, end_column=6, occurrence=1)
+        # jump if c is false:
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_FALSE',
+            line=2, end_line=2, column=15, end_column=16, occurrence=2)
+        # compare d and 0
+        self.assertOpcodeSourcePositionIs(compiled_code, 'COMPARE_OP',
+            line=4, end_line=4, column=8, end_column=13, occurrence=1)
+        # jump if comparison it True
+        self.assertOpcodeSourcePositionIs(compiled_code, 'POP_JUMP_IF_TRUE',
+            line=4, end_line=4, column=8, end_column=13, occurrence=2)
+
+    @unittest.skipIf(sys.flags.optimize, "Assertions are disabled in optimized mode")
+    def test_multiline_assert(self):
+        snippet = textwrap.dedent("""\
+            assert (a > 0 and
+                    bb > 0 and
+                    ccc == 1000000), "error msg"
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LOAD_COMMON_CONSTANT',
+            line=1, end_line=3, column=0, end_column=36, occurrence=1)
+        #  The "error msg":
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LOAD_CONST',
+            line=3, end_line=3, column=25, end_column=36, occurrence=2)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'CALL',
+            line=1, end_line=3, column=0, end_column=36, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RAISE_VARARGS',
+            line=1, end_line=3, column=8, end_column=22, occurrence=1)
+
+    def test_multiline_generator_expression(self):
+        snippet = textwrap.dedent("""\
+            ((x,
+                2*x)
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50))
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        compiled_code = compiled_code.co_consts[0]
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'YIELD_VALUE',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=4, end_line=4, column=7, end_column=14, occurrence=1)
+
+    def test_multiline_async_generator_expression(self):
+        snippet = textwrap.dedent("""\
+            ((x,
+                2*x)
+                async for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50))
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        compiled_code = compiled_code.co_consts[0]
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'YIELD_VALUE',
+            line=1, end_line=2, column=1, end_column=8, occurrence=2)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=1, end_line=6, column=0, end_column=32, occurrence=1)
+
+    def test_multiline_list_comprehension(self):
+        snippet = textwrap.dedent("""\
+            [(x,
+                2*x)
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50)]
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LIST_APPEND',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+
+    def test_multiline_async_list_comprehension(self):
+        snippet = textwrap.dedent("""\
+            async def f():
+                [(x,
+                    2*x)
+                    async for x
+                    in [1,2,3] if (x > 0
+                                   and x < 100
+                                   and x != 50)]
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        g = {}
+        eval(compiled_code, g)
+        compiled_code = g['f'].__code__
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'LIST_APPEND',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=2, end_line=7, column=4, end_column=36, occurrence=1)
+
+    def test_multiline_set_comprehension(self):
+        snippet = textwrap.dedent("""\
+            {(x,
+                2*x)
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'SET_ADD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=8, occurrence=1)
+
+    def test_multiline_async_set_comprehension(self):
+        snippet = textwrap.dedent("""\
+            async def f():
+                {(x,
+                    2*x)
+                    async for x
+                    in [1,2,3] if (x > 0
+                                   and x < 100
+                                   and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        g = {}
+        eval(compiled_code, g)
+        compiled_code = g['f'].__code__
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'SET_ADD',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=2, end_line=3, column=5, end_column=12, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=2, end_line=7, column=4, end_column=36, occurrence=1)
+
+    def test_multiline_dict_comprehension(self):
+        snippet = textwrap.dedent("""\
+            {x:
+                2*x
+                for x
+                in [1,2,3] if (x > 0
+                               and x < 100
+                               and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MAP_ADD',
+            line=1, end_line=2, column=1, end_column=7, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=1, end_line=2, column=1, end_column=7, occurrence=1)
+
+    def test_multiline_async_dict_comprehension(self):
+        snippet = textwrap.dedent("""\
+            async def f():
+                {x:
+                    2*x
+                    async for x
+                    in [1,2,3] if (x > 0
+                                   and x < 100
+                                   and x != 50)}
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        g = {}
+        eval(compiled_code, g)
+        compiled_code = g['f'].__code__
+        self.assertIsInstance(compiled_code, types.CodeType)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MAP_ADD',
+            line=2, end_line=3, column=5, end_column=11, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'JUMP_BACKWARD',
+            line=2, end_line=3, column=5, end_column=11, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'RETURN_VALUE',
+            line=2, end_line=7, column=4, end_column=36, occurrence=1)
+
+    def test_matchcase_sequence(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case a, b:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'UNPACK_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=13, occurrence=2)
+
+    def test_matchcase_sequence_wildcard(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case a, *b, c:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=17, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'UNPACK_EX',
+            line=2, end_line=2, column=9, end_column=17, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=17, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=17, occurrence=2)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=17, occurrence=3)
+
+    def test_matchcase_mapping(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case {"a" : a, "b": b}:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_MAPPING',
+            line=2, end_line=2, column=9, end_column=26, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_KEYS',
+            line=2, end_line=2, column=9, end_column=26, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=26, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=26, occurrence=2)
+
+    def test_matchcase_mapping_wildcard(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case {"a" : a, "b": b, **c}:
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_MAPPING',
+            line=2, end_line=2, column=9, end_column=31, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_KEYS',
+            line=2, end_line=2, column=9, end_column=31, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=31, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=31, occurrence=2)
+
+    def test_matchcase_class(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case C(a, b):
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_CLASS',
+            line=2, end_line=2, column=9, end_column=16, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'UNPACK_SEQUENCE',
+            line=2, end_line=2, column=9, end_column=16, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=16, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'STORE_NAME',
+            line=2, end_line=2, column=9, end_column=16, occurrence=2)
+
+    def test_matchcase_or(self):
+        snippet = textwrap.dedent("""\
+            match x:
+                case C(1) | C(2):
+                    pass
+            """)
+        compiled_code, _ = self.check_positions_against_ast(snippet)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_CLASS',
+            line=2, end_line=2, column=9, end_column=13, occurrence=1)
+        self.assertOpcodeSourcePositionIs(compiled_code, 'MATCH_CLASS',
+            line=2, end_line=2, column=16, end_column=20, occurrence=2)
+
     def test_very_long_line_end_offset(self):
         # Make sure we get the correct column offset for offsets
         # too large to store in a byte.
@@ -1209,16 +2263,16 @@ def test_complex_single_line_expression(self):
         snippet = "a - b @ (c * x['key'] + 23)"
 
         compiled_code, _ = self.check_positions_against_ast(snippet)
-        self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_SUBSCR',
+        self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
             line=1, end_line=1, column=13, end_column=21)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=9, end_column=21, occurrence=1)
+            line=1, end_line=1, column=9, end_column=21, occurrence=2)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=9, end_column=26, occurrence=2)
+            line=1, end_line=1, column=9, end_column=26, occurrence=3)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=4, end_column=27, occurrence=3)
+            line=1, end_line=1, column=4, end_column=27, occurrence=4)
         self.assertOpcodeSourcePositionIs(compiled_code, 'BINARY_OP',
-            line=1, end_line=1, column=0, end_column=27, occurrence=4)
+            line=1, end_line=1, column=0, end_column=27, occurrence=5)
 
     def test_multiline_assert_rewritten_as_method_call(self):
         # GH-94694: Don't crash if pytest rewrites a multiline assert as a
@@ -1268,7 +2322,9 @@ def f():
             with self.subTest(body):
                 namespace = {}
                 source = textwrap.dedent(source_template.format(body))
-                exec(source, namespace)
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', SyntaxWarning)
+                    exec(source, namespace)
                 code = namespace["f"].__code__
                 self.assertOpcodeSourcePositionIs(
                     code,
@@ -1314,7 +2370,7 @@ def test_method_call(self):
         source = "(\n lhs  \n   .    \n     rhs      \n       )()"
         code = compile(source, "<test>", "exec")
         self.assertOpcodeSourcePositionIs(
-            code, "LOAD_METHOD", line=4, end_line=4, column=5, end_column=8
+            code, "LOAD_ATTR", line=4, end_line=4, column=5, end_column=8
         )
         self.assertOpcodeSourcePositionIs(
             code, "CALL", line=4, end_line=5, column=5, end_column=10
@@ -1345,9 +2401,6 @@ def test_column_offset_deduplication(self):
         for source in [
             "lambda: a",
             "(a for b in c)",
-            "[a for b in c]",
-            "{a for b in c}",
-            "{a: b for c in d}",
         ]:
             with self.subTest(source):
                 code = compile(f"{source}, {source}", "<test>", "eval")
@@ -1360,6 +2413,141 @@ def test_column_offset_deduplication(self):
                     list(code.co_consts[1].co_positions()),
                 )
 
+    def test_load_super_attr(self):
+        source = "class C:\n  def __init__(self):\n    super().__init__()"
+        for const in compile(source, "<test>", "exec").co_consts[0].co_consts:
+            if isinstance(const, types.CodeType):
+                code = const
+                break
+        self.assertOpcodeSourcePositionIs(
+            code, "LOAD_GLOBAL", line=3, end_line=3, column=4, end_column=9
+        )
+
+    def test_lambda_return_position(self):
+        snippets = [
+            "f = lambda: x",
+            "f = lambda: 42",
+            "f = lambda: 1 + 2",
+            "f = lambda: a + b",
+        ]
+        for snippet in snippets:
+            with self.subTest(snippet=snippet):
+                lamb = run_code(snippet)["f"]
+                positions = lamb.__code__.co_positions()
+                # assert that all positions are within the lambda
+                for i, pos in enumerate(positions):
+                    with self.subTest(i=i, pos=pos):
+                        start_line, end_line, start_col, end_col = pos
+                        if i == 0 and start_col == end_col == 0:
+                            # ignore the RESUME in the beginning
+                            continue
+                        self.assertEqual(start_line, 1)
+                        self.assertEqual(end_line, 1)
+                        code_start = snippet.find(":") + 2
+                        code_end = len(snippet)
+                        self.assertGreaterEqual(start_col, code_start)
+                        self.assertLessEqual(end_col, code_end)
+                        self.assertGreaterEqual(end_col, start_col)
+                        self.assertLessEqual(end_col, code_end)
+
+    def test_return_in_with_positions(self):
+        # See gh-98442
+        def f():
+            with xyz:
+                1
+                2
+                3
+                4
+                return R
+
+        # All instructions should have locations on a single line
+        for instr in dis.get_instructions(f):
+            start_line, end_line, _, _ = instr.positions
+            self.assertEqual(start_line, end_line)
+
+        # Expect four `LOAD_CONST None` instructions:
+        # three for the no-exception __exit__ call, and one for the return.
+        # They should all have the locations of the context manager ('xyz').
+
+        load_none = [instr for instr in dis.get_instructions(f) if
+                     instr.opname == 'LOAD_CONST' and instr.argval is None]
+        return_value = [instr for instr in dis.get_instructions(f) if
+                        instr.opname == 'RETURN_VALUE']
+
+        self.assertEqual(len(load_none), 4)
+        self.assertEqual(len(return_value), 2)
+        for instr in load_none + return_value:
+            start_line, end_line, start_col, end_col = instr.positions
+            self.assertEqual(start_line, f.__code__.co_firstlineno + 1)
+            self.assertEqual(end_line, f.__code__.co_firstlineno + 1)
+            self.assertEqual(start_col, 17)
+            self.assertEqual(end_col, 20)
+
+
+class TestStaticAttributes(unittest.TestCase):
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: type object 'C' has no attribute '__static_attributes__'
+    def test_basic(self):
+        class C:
+            def f(self):
+                self.a = self.b = 42
+                # read fields are not included
+                self.f()
+                self.arr[3]
+
+        self.assertIsInstance(C.__static_attributes__, tuple)
+        self.assertEqual(sorted(C.__static_attributes__), ['a', 'b'])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: type object 'C' has no attribute '__static_attributes__'
+    def test_nested_function(self):
+        class C:
+            def f(self):
+                self.x = 1
+                self.y = 2
+                self.x = 3   # check deduplication
+
+            def g(self, obj):
+                self.y = 4
+                self.z = 5
+
+                def h(self, a):
+                    self.u = 6
+                    self.v = 7
+
+                obj.self = 8
+
+        self.assertEqual(sorted(C.__static_attributes__), ['u', 'v', 'x', 'y', 'z'])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: type object 'C' has no attribute '__static_attributes__'
+    def test_nested_class(self):
+        class C:
+            def f(self):
+                self.x = 42
+                self.y = 42
+
+            class D:
+                def g(self):
+                    self.y = 42
+                    self.z = 42
+
+        self.assertEqual(sorted(C.__static_attributes__), ['x', 'y'])
+        self.assertEqual(sorted(C.D.__static_attributes__), ['y', 'z'])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AttributeError: type object 'C' has no attribute '__static_attributes__'
+    def test_subclass(self):
+        class C:
+            def f(self):
+                self.x = 42
+                self.y = 42
+
+        class D(C):
+            def g(self):
+                self.y = 42
+                self.z = 42
+
+        self.assertEqual(sorted(C.__static_attributes__), ['x', 'y'])
+        self.assertEqual(sorted(D.__static_attributes__), ['y', 'z'])
+
 
 class TestExpressionStackSize(unittest.TestCase):
     # These tests check that the computed stack size for a code object
@@ -1393,28 +2581,23 @@ def test_if_else(self):
     def test_binop(self):
         self.check_stack_size("x + " * self.N + "x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 101 not less than or equal to 6
     def test_list(self):
         self.check_stack_size("[" + "x, " * self.N + "x]")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 101 not less than or equal to 6
     def test_tuple(self):
         self.check_stack_size("(" + "x, " * self.N + "x)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 101 not less than or equal to 6
     def test_set(self):
         self.check_stack_size("{" + "x, " * self.N + "x}")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 202 not less than or equal to 7
     def test_dict(self):
         self.check_stack_size("{" + "x:x, " * self.N + "x:x}")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 102 not less than or equal to 6
     def test_func_args(self):
         self.check_stack_size("f(" + "x, " * self.N + ")")
 
@@ -1422,8 +2605,7 @@ def test_func_kwargs(self):
         kwargs = (f'a{i}=x' for i in range(self.N))
         self.check_stack_size("f(" +  ", ".join(kwargs) + ")")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 102 not less than or equal to 6
     def test_meth_args(self):
         self.check_stack_size("o.m(" + "x, " * self.N + ")")
 
@@ -1460,7 +2642,9 @@ def compile_snippet(i):
             script = """def func():\n""" + i * snippet
             if async_:
                 script = "async " + script
-            code = compile(script, "<script>", "exec")
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore', SyntaxWarning)
+                code = compile(script, "<script>", "exec")
             exec(code, ns, ns)
             return ns['func'].__code__
 
@@ -1773,6 +2957,67 @@ def test_return_inside_async_with_block(self):
             """
         self.check_stack_size(snippet, async_=True)
 
+@support.cpython_only
+@unittest.skipIf(_testinternalcapi is None, 'need _testinternalcapi module')
+class TestInstructionSequence(unittest.TestCase):
+    def compare_instructions(self, seq, expected):
+        self.assertEqual([(opcode.opname[i[0]],) + i[1:] for i in seq.get_instructions()],
+                         expected)
+
+    def test_basics(self):
+        seq = _testinternalcapi.new_instruction_sequence()
+
+        def add_op(seq, opname, oparg, bl, bc=0, el=0, ec=0):
+            seq.addop(opcode.opmap[opname], oparg, bl, bc, el, el)
+
+        add_op(seq, 'LOAD_CONST', 1, 1)
+        add_op(seq, 'JUMP', lbl1 := seq.new_label(), 2)
+        add_op(seq, 'LOAD_CONST', 1, 3)
+        add_op(seq, 'JUMP', lbl2 := seq.new_label(), 4)
+        seq.use_label(lbl1)
+        add_op(seq, 'LOAD_CONST', 2, 4)
+        seq.use_label(lbl2)
+        add_op(seq, 'RETURN_VALUE', 0, 3)
+
+        expected = [('LOAD_CONST', 1, 1),
+                    ('JUMP', 4, 2),
+                    ('LOAD_CONST', 1, 3),
+                    ('JUMP', 5, 4),
+                    ('LOAD_CONST', 2, 4),
+                    ('RETURN_VALUE', None, 3),
+                   ]
+
+        self.compare_instructions(seq, [ex + (0,0,0) for ex in expected])
+
+    def test_nested(self):
+        seq = _testinternalcapi.new_instruction_sequence()
+        seq.addop(opcode.opmap['LOAD_CONST'], 1, 1, 0, 0, 0)
+        nested = _testinternalcapi.new_instruction_sequence()
+        nested.addop(opcode.opmap['LOAD_CONST'], 2, 2, 0, 0, 0)
+
+        self.compare_instructions(seq, [('LOAD_CONST', 1, 1, 0, 0, 0)])
+        self.compare_instructions(nested, [('LOAD_CONST', 2, 2, 0, 0, 0)])
+
+        seq.add_nested(nested)
+        self.compare_instructions(seq, [('LOAD_CONST', 1, 1, 0, 0, 0)])
+        self.compare_instructions(seq.get_nested()[0], [('LOAD_CONST', 2, 2, 0, 0, 0)])
+
+    def test_static_attributes_are_sorted(self):
+        code = (
+            'class T:\n'
+            '    def __init__(self):\n'
+            '        self.{V1} = 10\n'
+            '        self.{V2} = 10\n'
+            '    def foo(self):\n'
+            '        self.{V3} = 10\n'
+        )
+        attributes = ("a", "b", "c")
+        for perm in itertools.permutations(attributes):
+            var_names = {f'V{i + 1}': name for i, name in enumerate(perm)}
+            ns = run_code(code.format(**var_names))
+            t = ns['T']
+            self.assertEqual(t.__static_attributes__, attributes)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index ec851f939c9..232c1ca6d7c 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -1147,7 +1147,6 @@ def test_intrinsic_2(self):
         self.assertIn("CALL_INTRINSIC_2         1 (INTRINSIC_PREP_RERAISE_STAR)",
                       self.get_disassembly("try: pass\nexcept* Exception: x"))
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_big_linenos(self):
         def func(count):
             namespace = {}
@@ -2119,7 +2118,6 @@ def test_oparg_alias(self):
                                   positions=None)
         self.assertEqual(instruction.arg, instruction.oparg)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_show_caches_with_label(self):
         def f(x, y, z):
             if x:
@@ -2238,6 +2236,7 @@ def f(opcode, oparg, offset, *init_args):
     def get_instructions(self, code):
         return dis._get_instructions_bytes(code)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; no inline caches
     def test_start_offset(self):
         # When no extended args are present,
         # start_offset should be equal to offset
@@ -2290,6 +2289,7 @@ def last_item(iterable):
         self.assertEqual(14, instructions[6].offset)
         self.assertEqual(8, instructions[6].start_offset)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; no inline caches
     def test_cache_offset_and_end_offset(self):
         code = bytes([
             opcode.opmap["LOAD_GLOBAL"], 0x01,
@@ -2422,7 +2422,6 @@ def test__find_imports(self):
                 self.assertEqual(len(res), 1)
                 self.assertEqual(res[0], expected)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test__find_store_names(self):
         cases = [
             ("x+y", ()),
diff --git a/Lib/test/test_monitoring.py b/Lib/test/test_monitoring.py
new file mode 100644
index 00000000000..2b530e35563
--- /dev/null
+++ b/Lib/test/test_monitoring.py
@@ -0,0 +1,2470 @@
+"""Test suite for the sys.monitoring."""
+
+import collections
+import dis
+import functools
+import inspect
+import math
+import operator
+import sys
+import textwrap
+import types
+import unittest
+
+import test.support
+from test.support import requires_specialization_ft, script_helper
+
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
+
+PAIR = (0,1)
+
+def f1():
+    pass
+
+def f2():
+    len([])
+    sys.getsizeof(0)
+
+def floop():
+    for item in PAIR:
+        pass
+
+def gen():
+    yield
+    yield
+
+def g1():
+    for _ in gen():
+        pass
+
+TEST_TOOL = 2
+TEST_TOOL2 = 3
+TEST_TOOL3 = 4
+
+def nth_line(func, offset):
+    return func.__code__.co_firstlineno + offset
+
+class MonitoringBasicTest(unittest.TestCase):
+
+    def tearDown(self):
+        sys.monitoring.free_tool_id(TEST_TOOL)
+
+    def test_has_objects(self):
+        m = sys.monitoring
+        m.events
+        m.use_tool_id
+        m.clear_tool_id
+        m.free_tool_id
+        m.get_tool
+        m.get_events
+        m.set_events
+        m.get_local_events
+        m.set_local_events
+        m.register_callback
+        m.restart_events
+        m.DISABLE
+        m.MISSING
+        m.events.NO_EVENTS
+
+    def test_tool(self):
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        self.assertEqual(sys.monitoring.get_tool(TEST_TOOL), "MonitoringTest.Tool")
+        sys.monitoring.set_events(TEST_TOOL, 15)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 15)
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.C_RETURN)
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.C_RAISE)
+        sys.monitoring.free_tool_id(TEST_TOOL)
+        self.assertEqual(sys.monitoring.get_tool(TEST_TOOL), None)
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_events(TEST_TOOL, sys.monitoring.events.CALL)
+
+    def test_clear(self):
+        events = []
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        sys.monitoring.register_callback(TEST_TOOL, E.PY_START, lambda *args: events.append(args))
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, lambda *args: events.append(args))
+        def f():
+            a = 1
+        sys.monitoring.set_local_events(TEST_TOOL, f.__code__, E.LINE)
+        sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+
+        f()
+        sys.monitoring.clear_tool_id(TEST_TOOL)
+        f()
+
+        # the first f() should trigger a PY_START and a LINE event
+        # the second f() after clear_tool_id should not trigger any event
+        # the callback function should be cleared as well
+        self.assertEqual(len(events), 2)
+        callback = sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+        self.assertIs(callback, None)
+
+        sys.monitoring.free_tool_id(TEST_TOOL)
+
+        events = []
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, lambda *args: events.append(args))
+        sys.monitoring.set_local_events(TEST_TOOL, f.__code__, E.LINE)
+        f()
+        sys.monitoring.free_tool_id(TEST_TOOL)
+        sys.monitoring.use_tool_id(TEST_TOOL, "MonitoringTest.Tool")
+        f()
+        # the first f() should trigger a LINE event, and even if we use the
+        # tool id immediately after freeing it, the second f() should not
+        # trigger any event
+        self.assertEqual(len(events), 1)
+        sys.monitoring.free_tool_id(TEST_TOOL)
+
+
+class MonitoringTestBase:
+
+    def setUp(self):
+        # Check that a previous test hasn't left monitoring on.
+        for tool in range(6):
+            self.assertEqual(sys.monitoring.get_events(tool), 0)
+        self.assertIs(sys.monitoring.get_tool(TEST_TOOL), None)
+        self.assertIs(sys.monitoring.get_tool(TEST_TOOL2), None)
+        self.assertIs(sys.monitoring.get_tool(TEST_TOOL3), None)
+        sys.monitoring.use_tool_id(TEST_TOOL, "test " + self.__class__.__name__)
+        sys.monitoring.use_tool_id(TEST_TOOL2, "test2 " + self.__class__.__name__)
+        sys.monitoring.use_tool_id(TEST_TOOL3, "test3 " + self.__class__.__name__)
+
+    def tearDown(self):
+        # Check that test hasn't left monitoring on.
+        for tool in range(6):
+            self.assertEqual(sys.monitoring.get_events(tool), 0)
+        sys.monitoring.free_tool_id(TEST_TOOL)
+        sys.monitoring.free_tool_id(TEST_TOOL2)
+        sys.monitoring.free_tool_id(TEST_TOOL3)
+
+
+class MonitoringCountTest(MonitoringTestBase, unittest.TestCase):
+
+    def check_event_count(self, func, event, expected):
+
+        class Counter:
+            def __init__(self):
+                self.count = 0
+            def __call__(self, *args):
+                self.count += 1
+
+        counter = Counter()
+        sys.monitoring.register_callback(TEST_TOOL, event, counter)
+        if event == E.C_RETURN or event == E.C_RAISE:
+            sys.monitoring.set_events(TEST_TOOL, E.CALL)
+        else:
+            sys.monitoring.set_events(TEST_TOOL, event)
+        self.assertEqual(counter.count, 0)
+        counter.count = 0
+        func()
+        self.assertEqual(counter.count, expected)
+        prev = sys.monitoring.register_callback(TEST_TOOL, event, None)
+        counter.count = 0
+        func()
+        self.assertEqual(counter.count, 0)
+        self.assertEqual(prev, counter)
+        sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_start_count(self):
+        self.check_event_count(f1, E.PY_START, 1)
+
+    def test_resume_count(self):
+        self.check_event_count(g1, E.PY_RESUME, 2)
+
+    def test_return_count(self):
+        self.check_event_count(f1, E.PY_RETURN, 1)
+
+    def test_call_count(self):
+        self.check_event_count(f2, E.CALL, 3)
+
+    def test_c_return_count(self):
+        self.check_event_count(f2, E.C_RETURN, 2)
+
+
+E = sys.monitoring.events
+
+INSTRUMENTED_EVENTS = [
+    (E.PY_START, "start"),
+    (E.PY_RESUME, "resume"),
+    (E.PY_RETURN, "return"),
+    (E.PY_YIELD, "yield"),
+    (E.JUMP, "jump"),
+    (E.BRANCH, "branch"),
+]
+
+EXCEPT_EVENTS = [
+    (E.RAISE, "raise"),
+    (E.PY_UNWIND, "unwind"),
+    (E.EXCEPTION_HANDLED, "exception_handled"),
+]
+
+SIMPLE_EVENTS = INSTRUMENTED_EVENTS + EXCEPT_EVENTS + [
+    (E.C_RAISE, "c_raise"),
+    (E.C_RETURN, "c_return"),
+]
+
+
+SIMPLE_EVENT_SET = functools.reduce(operator.or_, [ev for (ev, _) in SIMPLE_EVENTS], 0) | E.CALL
+
+
+def just_pass():
+    pass
+
+just_pass.events = [
+    "py_call",
+    "start",
+    "return",
+]
+
+def just_raise():
+    raise Exception
+
+just_raise.events = [
+    'py_call',
+    "start",
+    "raise",
+    "unwind",
+]
+
+def just_call():
+    len([])
+
+just_call.events = [
+    'py_call',
+    "start",
+    "c_call",
+    "c_return",
+    "return",
+]
+
+def caught():
+    try:
+        1/0
+    except Exception:
+        pass
+
+caught.events = [
+    'py_call',
+    "start",
+    "raise",
+    "exception_handled",
+    "branch",
+    "return",
+]
+
+def nested_call():
+    just_pass()
+
+nested_call.events = [
+    "py_call",
+    "start",
+    "py_call",
+    "start",
+    "return",
+    "return",
+]
+
+PY_CALLABLES = (types.FunctionType, types.MethodType)
+
+class MonitoringEventsBase(MonitoringTestBase):
+
+    def gather_events(self, func):
+        events = []
+        for event, event_name in SIMPLE_EVENTS:
+            def record(*args, event_name=event_name):
+                events.append(event_name)
+            sys.monitoring.register_callback(TEST_TOOL, event, record)
+        def record_call(code, offset, obj, arg):
+            if isinstance(obj, PY_CALLABLES):
+                events.append("py_call")
+            else:
+                events.append("c_call")
+        sys.monitoring.register_callback(TEST_TOOL, E.CALL, record_call)
+        sys.monitoring.set_events(TEST_TOOL, SIMPLE_EVENT_SET)
+        events = []
+        try:
+            func()
+        except:
+            pass
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        #Remove the final event, the call to `sys.monitoring.set_events`
+        events = events[:-1]
+        return events
+
+    def check_events(self, func, expected=None):
+        events = self.gather_events(func)
+        if expected is None:
+            expected = func.events
+        self.assertEqual(events, expected)
+
+class MonitoringEventsTest(MonitoringEventsBase, unittest.TestCase):
+
+    def test_just_pass(self):
+        self.check_events(just_pass)
+
+    def test_just_raise(self):
+        try:
+            self.check_events(just_raise)
+        except Exception:
+            pass
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 0)
+
+    def test_just_call(self):
+        self.check_events(just_call)
+
+    def test_caught(self):
+        self.check_events(caught)
+
+    def test_nested_call(self):
+        self.check_events(nested_call)
+
+UP_EVENTS = (E.C_RETURN, E.C_RAISE, E.PY_RETURN, E.PY_UNWIND, E.PY_YIELD)
+DOWN_EVENTS = (E.PY_START, E.PY_RESUME)
+
+from test.profilee import testfunc
+
+class SimulateProfileTest(MonitoringEventsBase, unittest.TestCase):
+
+    def test_balanced(self):
+        events = self.gather_events(testfunc)
+        c = collections.Counter(events)
+        self.assertEqual(c["c_call"], c["c_return"])
+        self.assertEqual(c["start"], c["return"] + c["unwind"])
+        self.assertEqual(c["raise"], c["exception_handled"] + c["unwind"])
+
+    def test_frame_stack(self):
+        self.maxDiff = None
+        stack = []
+        errors = []
+        seen = set()
+        def up(*args):
+            frame = sys._getframe(1)
+            if not stack:
+                errors.append("empty")
+            else:
+                expected = stack.pop()
+                if frame != expected:
+                    errors.append(f" Popping {frame} expected {expected}")
+        def down(*args):
+            frame = sys._getframe(1)
+            stack.append(frame)
+            seen.add(frame.f_code)
+        def call(code, offset, callable, arg):
+            if not isinstance(callable, PY_CALLABLES):
+                stack.append(sys._getframe(1))
+        for event in UP_EVENTS:
+            sys.monitoring.register_callback(TEST_TOOL, event, up)
+        for event in DOWN_EVENTS:
+            sys.monitoring.register_callback(TEST_TOOL, event, down)
+        sys.monitoring.register_callback(TEST_TOOL, E.CALL, call)
+        sys.monitoring.set_events(TEST_TOOL, SIMPLE_EVENT_SET)
+        testfunc()
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertEqual(errors, [])
+        self.assertEqual(stack, [sys._getframe()])
+        self.assertEqual(len(seen), 9)
+
+
+class CounterWithDisable:
+
+    def __init__(self):
+        self.disable = False
+        self.count = 0
+
+    def __call__(self, *args):
+        self.count += 1
+        if self.disable:
+            return sys.monitoring.DISABLE
+
+
+class RecorderWithDisable:
+
+    def __init__(self, events):
+        self.disable = False
+        self.events = events
+
+    def __call__(self, code, event):
+        self.events.append(event)
+        if self.disable:
+            return sys.monitoring.DISABLE
+
+
+class MontoringDisableAndRestartTest(MonitoringTestBase, unittest.TestCase):
+
+    def test_disable(self):
+        try:
+            counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            self.assertEqual(counter.count, 0)
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 1)
+            counter.disable = True
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 1)
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 0)
+            sys.monitoring.set_events(TEST_TOOL, 0)
+        finally:
+            sys.monitoring.restart_events()
+
+    def test_restart(self):
+        try:
+            counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            counter.disable = True
+            f1()
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 0)
+            sys.monitoring.restart_events()
+            counter.count = 0
+            f1()
+            self.assertEqual(counter.count, 1)
+            sys.monitoring.set_events(TEST_TOOL, 0)
+        finally:
+            sys.monitoring.restart_events()
+
+
+class MultipleMonitorsTest(MonitoringTestBase, unittest.TestCase):
+
+    def test_two_same(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2)})
+            counter1.count = 0
+            counter2.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (1, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+    def test_three_same(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            counter3 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
+            sys.monitoring.register_callback(TEST_TOOL3, E.PY_START, counter3)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL3, E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL3), E.PY_START)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2) | (1 << TEST_TOOL3)})
+            counter1.count = 0
+            counter2.count = 0
+            counter3.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            count3 = counter3.count
+            self.assertEqual((count1, count2, count3), (1, 1, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.set_events(TEST_TOOL3, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL3, E.PY_START, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+    def test_two_different(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_RETURN, counter2)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_RETURN)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_RETURN)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': 1 << TEST_TOOL, 'PY_RETURN': 1 << TEST_TOOL2})
+            counter1.count = 0
+            counter2.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (1, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_RETURN, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+    def test_two_with_disable(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            counter1 = CounterWithDisable()
+            counter2 = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, counter1)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, counter2)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+            sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+            self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+            self.assertEqual(sys.monitoring._all_events(), {'PY_START': (1 << TEST_TOOL) | (1 << TEST_TOOL2)})
+            counter1.count = 0
+            counter2.count = 0
+            counter1.disable = True
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (1, 1))
+            counter1.count = 0
+            counter2.count = 0
+            f1()
+            count1 = counter1.count
+            count2 = counter2.count
+            self.assertEqual((count1, count2), (0, 1))
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_START, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.PY_START, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def test_with_instruction_event(self):
+        """Test that the second tool can set events with instruction events set by the first tool."""
+        def f():
+            pass
+        code = f.__code__
+
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.set_local_events(TEST_TOOL, code, E.INSTRUCTION | E.LINE)
+            sys.monitoring.set_local_events(TEST_TOOL2, code, E.LINE)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            self.assertEqual(sys.monitoring._all_events(), {})
+
+
+class LineMonitoringTest(MonitoringTestBase, unittest.TestCase):
+
+    def test_lines_single(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+            sys.monitoring.set_events(TEST_TOOL, E.LINE)
+            f1()
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            start = nth_line(LineMonitoringTest.test_lines_single, 0)
+            self.assertEqual(events, [start+7, nth_line(f1, 1), start+8])
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def test_lines_loop(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+            sys.monitoring.set_events(TEST_TOOL, E.LINE)
+            floop()
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            start = nth_line(LineMonitoringTest.test_lines_loop, 0)
+            floop_1 = nth_line(floop, 1)
+            floop_2 = nth_line(floop, 2)
+            self.assertEqual(
+                events,
+                [start+7, floop_1, floop_2, floop_1, floop_2, floop_1, start+8]
+            )
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def test_lines_two(self):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            events2 = []
+            recorder2 = RecorderWithDisable(events2)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, recorder2)
+            sys.monitoring.set_events(TEST_TOOL, E.LINE); sys.monitoring.set_events(TEST_TOOL2, E.LINE)
+            f1()
+            sys.monitoring.set_events(TEST_TOOL, 0); sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, None)
+            start = nth_line(LineMonitoringTest.test_lines_two, 0)
+            expected = [start+10, nth_line(f1, 1), start+11]
+            self.assertEqual(events, expected)
+            self.assertEqual(events2, expected)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+            sys.monitoring.set_events(TEST_TOOL2, 0)
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            sys.monitoring.register_callback(TEST_TOOL2, E.LINE, None)
+            self.assertEqual(sys.monitoring._all_events(), {})
+            sys.monitoring.restart_events()
+
+    def check_lines(self, func, expected, tool=TEST_TOOL):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            events = []
+            recorder = RecorderWithDisable(events)
+            sys.monitoring.register_callback(tool, E.LINE, recorder)
+            sys.monitoring.set_events(tool, E.LINE)
+            func()
+            sys.monitoring.set_events(tool, 0)
+            sys.monitoring.register_callback(tool, E.LINE, None)
+            lines = [ line - func.__code__.co_firstlineno for line in events[1:-1] ]
+            self.assertEqual(lines, expected)
+        finally:
+            sys.monitoring.set_events(tool, 0)
+
+
+    def test_linear(self):
+
+        def func():
+            line = 1
+            line = 2
+            line = 3
+            line = 4
+            line = 5
+
+        self.check_lines(func, [1,2,3,4,5])
+
+    def test_branch(self):
+        def func():
+            if "true".startswith("t"):
+                line = 2
+                line = 3
+            else:
+                line = 5
+            line = 6
+
+        self.check_lines(func, [1,2,3,6])
+
+    def test_try_except(self):
+
+        def func1():
+            try:
+                line = 2
+                line = 3
+            except:
+                line = 5
+            line = 6
+
+        self.check_lines(func1, [1,2,3,6])
+
+        def func2():
+            try:
+                line = 2
+                raise 3
+            except:
+                line = 5
+            line = 6
+
+        self.check_lines(func2, [1,2,3,4,5,6])
+
+    def test_generator_with_line(self):
+
+        def f():
+            def a():
+                yield
+            def b():
+                yield from a()
+            next(b())
+
+        self.check_lines(f, [1,3,5,4,2,4])
+
+class TestDisable(MonitoringTestBase, unittest.TestCase):
+
+    def gen(self, cond):
+        for i in range(10):
+            if cond:
+                yield 1
+            else:
+                yield 2
+
+    def raise_handle_reraise(self):
+        try:
+            1/0
+        except:
+            raise
+
+    def test_disable_legal_events(self):
+        for event, name in INSTRUMENTED_EVENTS:
+            try:
+                counter = CounterWithDisable()
+                counter.disable = True
+                sys.monitoring.register_callback(TEST_TOOL, event, counter)
+                sys.monitoring.set_events(TEST_TOOL, event)
+                for _ in self.gen(1):
+                    pass
+                self.assertLess(counter.count, 4)
+            finally:
+                sys.monitoring.set_events(TEST_TOOL, 0)
+                sys.monitoring.register_callback(TEST_TOOL, event, None)
+
+
+    def test_disable_illegal_events(self):
+        for event, name in EXCEPT_EVENTS:
+            try:
+                counter = CounterWithDisable()
+                counter.disable = True
+                sys.monitoring.register_callback(TEST_TOOL, event, counter)
+                sys.monitoring.set_events(TEST_TOOL, event)
+                with self.assertRaises(ValueError):
+                    self.raise_handle_reraise()
+            finally:
+                sys.monitoring.set_events(TEST_TOOL, 0)
+                sys.monitoring.register_callback(TEST_TOOL, event, None)
+
+
+class ExceptionRecorder:
+
+    event_type = E.RAISE
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("raise", type(exc)))
+
+class CheckEvents(MonitoringTestBase, unittest.TestCase):
+
+    def get_events(self, func, tool, recorders):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                ev = recorder.event_type
+                sys.monitoring.register_callback(tool, ev, recorder(event_list))
+                all_events |= ev
+            sys.monitoring.set_events(tool, all_events)
+            func()
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            return event_list
+        finally:
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+    def check_events(self, func, expected, tool=TEST_TOOL, recorders=(ExceptionRecorder,)):
+        events = self.get_events(func, tool, recorders)
+        self.assertEqual(events, expected)
+
+    def check_balanced(self, func, recorders):
+        events = self.get_events(func, TEST_TOOL, recorders)
+        self.assertEqual(len(events)%2, 0)
+        for r, h in zip(events[::2],events[1::2]):
+            r0 = r[0]
+            self.assertIn(r0, ("raise", "reraise"))
+            h0 = h[0]
+            self.assertIn(h0, ("handled", "unwind"))
+            self.assertEqual(r[1], h[1])
+
+
+class StopiterationRecorder(ExceptionRecorder):
+
+    event_type = E.STOP_ITERATION
+
+class ReraiseRecorder(ExceptionRecorder):
+
+    event_type = E.RERAISE
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("reraise", type(exc)))
+
+class UnwindRecorder(ExceptionRecorder):
+
+    event_type = E.PY_UNWIND
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("unwind", type(exc), code.co_name))
+
+class ExceptionHandledRecorder(ExceptionRecorder):
+
+    event_type = E.EXCEPTION_HANDLED
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("handled", type(exc)))
+
+class ThrowRecorder(ExceptionRecorder):
+
+    event_type = E.PY_THROW
+
+    def __call__(self, code, offset, exc):
+        self.events.append(("throw", type(exc)))
+
+class CallRecorder:
+
+    event_type = E.CALL
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, func, arg):
+        self.events.append(("call", func.__name__, arg))
+
+class ReturnRecorder:
+
+    event_type = E.PY_RETURN
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, val):
+        self.events.append(("return", code.co_name, val))
+
+
+class ExceptionMonitoringTest(CheckEvents):
+
+    exception_recorders = (
+        ExceptionRecorder,
+        ReraiseRecorder,
+        ExceptionHandledRecorder,
+        UnwindRecorder
+    )
+
+    def test_simple_try_except(self):
+
+        def func1():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func1, [("raise", KeyError)])
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    def test_implicit_stop_iteration(self):
+        """Generators are documented as raising a StopIteration
+           when they terminate.
+           However, we don't do that if we can avoid it, for speed.
+           sys.monitoring handles that by injecting a STOP_ITERATION
+           event when we would otherwise have skip the RAISE event.
+           This test checks that both paths record an equivalent event.
+           """
+
+        def gen():
+            yield 1
+            return 2
+
+        def implicit_stop_iteration(iterator=None):
+            if iterator is None:
+                iterator = gen()
+            for _ in iterator:
+                pass
+
+        recorders=(ExceptionRecorder, StopiterationRecorder,)
+        expected = [("raise", StopIteration)]
+
+        # Make sure that the loop is unspecialized, and that it will not
+        # re-specialize immediately, so that we can we can test the
+        # unspecialized version of the loop first.
+        # Note: this assumes that we don't specialize loops over sets.
+        implicit_stop_iteration(set(range(_testinternalcapi.SPECIALIZATION_THRESHOLD)))
+
+        # This will record a RAISE event for the StopIteration.
+        self.check_events(implicit_stop_iteration, expected, recorders=recorders)
+
+        # Now specialize, so that we see a STOP_ITERATION event.
+        for _ in range(_testinternalcapi.SPECIALIZATION_COOLDOWN):
+            implicit_stop_iteration()
+
+        # This will record a STOP_ITERATION event for the StopIteration.
+        self.check_events(implicit_stop_iteration, expected, recorders=recorders)
+
+    initial = [
+        ("raise", ZeroDivisionError),
+        ("handled", ZeroDivisionError)
+    ]
+
+    reraise = [
+        ("reraise", ZeroDivisionError),
+        ("handled", ZeroDivisionError)
+    ]
+
+    def test_explicit_reraise(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except:
+                    raise
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_explicit_reraise_named(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except Exception as ex:
+                    raise
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_implicit_reraise(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except ValueError:
+                    pass
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+
+    def test_implicit_reraise_named(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                except ValueError as ex:
+                    pass
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_try_finally(self):
+
+        def func():
+            try:
+                try:
+                    1/0
+                finally:
+                    pass
+            except:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_async_for(self):
+
+        def func():
+
+            async def async_generator():
+                for i in range(1):
+                    raise ZeroDivisionError
+                    yield i
+
+            async def async_loop():
+                try:
+                    async for item in async_generator():
+                        pass
+                except Exception:
+                    pass
+
+            try:
+                async_loop().send(None)
+            except StopIteration:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+    def test_throw(self):
+
+        def gen():
+            yield 1
+            yield 2
+
+        def func():
+            try:
+                g = gen()
+                next(g)
+                g.throw(IndexError)
+            except IndexError:
+                pass
+
+        self.check_balanced(
+            func,
+            recorders = self.exception_recorders)
+
+        events = self.get_events(
+            func,
+            TEST_TOOL,
+            self.exception_recorders + (ThrowRecorder,)
+        )
+        self.assertEqual(events[0], ("throw", IndexError))
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    @requires_specialization_ft
+    def test_no_unwind_for_shim_frame(self):
+        class ValueErrorRaiser:
+            def __init__(self):
+                raise ValueError()
+
+        def f():
+            try:
+                return ValueErrorRaiser()
+            except ValueError:
+                pass
+
+        for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+            f()
+        recorders = (
+            ReturnRecorder,
+            UnwindRecorder
+        )
+        events = self.get_events(f, TEST_TOOL, recorders)
+        adaptive_insts = dis.get_instructions(f, adaptive=True)
+        self.assertIn(
+            "CALL_ALLOC_AND_ENTER_INIT",
+            [i.opname for i in adaptive_insts]
+        )
+        #There should be only one unwind event
+        expected = [
+            ('unwind', ValueError, '__init__'),
+            ('return', 'f', None),
+        ]
+
+        self.assertEqual(events, expected)
+
+    # gh-140373
+    def test_gen_unwind(self):
+        def gen():
+            yield 1
+
+        def f():
+            g = gen()
+            next(g)
+            g.close()
+
+        recorders = (
+            UnwindRecorder,
+        )
+        events = self.get_events(f, TEST_TOOL, recorders)
+        expected = [
+            ("unwind", GeneratorExit, "gen"),
+        ]
+        self.assertEqual(events, expected)
+
+class LineRecorder:
+
+    event_type = E.LINE
+
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, line):
+        self.events.append(("line", code.co_name, line - code.co_firstlineno))
+
+class CEventRecorder:
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset, func, arg):
+        self.events.append((self.event_name, func.__name__, arg))
+
+class CReturnRecorder(CEventRecorder):
+
+    event_type = E.C_RETURN
+    event_name = "C return"
+
+class CRaiseRecorder(CEventRecorder):
+
+    event_type = E.C_RAISE
+    event_name = "C raise"
+
+MANY_RECORDERS = ExceptionRecorder, CallRecorder, LineRecorder, CReturnRecorder, CRaiseRecorder
+
+class TestManyEvents(CheckEvents):
+
+    def test_simple(self):
+
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = MANY_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('call', 'func1', sys.monitoring.MISSING),
+            ('line', 'func1', 1),
+            ('line', 'func1', 2),
+            ('line', 'func1', 3),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)])
+
+    def test_c_call(self):
+
+        def func2():
+            line1 = 1
+            [].append(2)
+            line3 = 3
+
+        self.check_events(func2, recorders = MANY_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('call', 'func2', sys.monitoring.MISSING),
+            ('line', 'func2', 1),
+            ('line', 'func2', 2),
+            ('call', 'append', [2]),
+            ('C return', 'append', [2]),
+            ('line', 'func2', 3),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)])
+
+    def test_try_except(self):
+
+        def func3():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func3, recorders = MANY_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('call', 'func3', sys.monitoring.MISSING),
+            ('line', 'func3', 1),
+            ('line', 'func3', 2),
+            ('line', 'func3', 3),
+            ('raise', KeyError),
+            ('line', 'func3', 4),
+            ('line', 'func3', 5),
+            ('line', 'func3', 6),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)])
+
+class InstructionRecorder:
+
+    event_type = E.INSTRUCTION
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, offset):
+        # Filter out instructions in check_events to lower noise
+        if code.co_name != "get_events":
+            self.events.append(("instruction", code.co_name, offset))
+
+
+LINE_AND_INSTRUCTION_RECORDERS = InstructionRecorder, LineRecorder
+
+class TestLineAndInstructionEvents(CheckEvents):
+    maxDiff = None
+
+    def test_simple(self):
+
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func1', 1),
+            ('instruction', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 6),
+            ('instruction', 'func1', 8),
+            ('line', 'func1', 3),
+            ('instruction', 'func1', 10),
+            ('instruction', 'func1', 12),
+            ('instruction', 'func1', 14),
+            ('instruction', 'func1', 16),
+            ('line', 'get_events', 11)])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - instruction offsets differ from CPython
+    def test_c_call(self):
+
+        def func2():
+            line1 = 1
+            [].append(2)
+            line3 = 3
+
+        self.check_events(func2, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func2', 1),
+            ('instruction', 'func2', 2),
+            ('instruction', 'func2', 4),
+            ('line', 'func2', 2),
+            ('instruction', 'func2', 6),
+            ('instruction', 'func2', 8),
+            ('instruction', 'func2', 28),
+            ('instruction', 'func2', 30),
+            ('instruction', 'func2', 38),
+            ('line', 'func2', 3),
+            ('instruction', 'func2', 40),
+            ('instruction', 'func2', 42),
+            ('instruction', 'func2', 44),
+            ('instruction', 'func2', 46),
+            ('line', 'get_events', 11)])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - instruction offsets differ from CPython
+    def test_try_except(self):
+
+        def func3():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func3, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func3', 1),
+            ('instruction', 'func3', 2),
+            ('line', 'func3', 2),
+            ('instruction', 'func3', 4),
+            ('instruction', 'func3', 6),
+            ('line', 'func3', 3),
+            ('instruction', 'func3', 8),
+            ('instruction', 'func3', 18),
+            ('instruction', 'func3', 20),
+            ('line', 'func3', 4),
+            ('instruction', 'func3', 22),
+            ('line', 'func3', 5),
+            ('instruction', 'func3', 24),
+            ('instruction', 'func3', 26),
+            ('instruction', 'func3', 28),
+            ('line', 'func3', 6),
+            ('instruction', 'func3', 30),
+            ('instruction', 'func3', 32),
+            ('instruction', 'func3', 34),
+            ('instruction', 'func3', 36),
+            ('line', 'get_events', 11)])
+
+    def test_with_restart(self):
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func1', 1),
+            ('instruction', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 6),
+            ('instruction', 'func1', 8),
+            ('line', 'func1', 3),
+            ('instruction', 'func1', 10),
+            ('instruction', 'func1', 12),
+            ('instruction', 'func1', 14),
+            ('instruction', 'func1', 16),
+            ('line', 'get_events', 11)])
+
+        sys.monitoring.restart_events()
+
+        self.check_events(func1, recorders = LINE_AND_INSTRUCTION_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func1', 1),
+            ('instruction', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 6),
+            ('instruction', 'func1', 8),
+            ('line', 'func1', 3),
+            ('instruction', 'func1', 10),
+            ('instruction', 'func1', 12),
+            ('instruction', 'func1', 14),
+            ('instruction', 'func1', 16),
+            ('line', 'get_events', 11)])
+
+    def test_turn_off_only_instruction(self):
+        """
+        LINE events should be recorded after INSTRUCTION event is turned off
+        """
+        events = []
+        def line(*args):
+            events.append("line")
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, line)
+        sys.monitoring.register_callback(TEST_TOOL, E.INSTRUCTION, lambda *args: None)
+        sys.monitoring.set_events(TEST_TOOL, E.LINE | E.INSTRUCTION)
+        sys.monitoring.set_events(TEST_TOOL, E.LINE)
+        events = []
+        a = 0
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertGreater(len(events), 0)
+
+class TestInstallIncrementally(MonitoringTestBase, unittest.TestCase):
+
+    def check_events(self, func, must_include, tool=TEST_TOOL, recorders=(ExceptionRecorder,)):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                all_events |= recorder.event_type
+                sys.monitoring.set_events(tool, all_events)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, recorder(event_list))
+            func()
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            for line in must_include:
+                self.assertIn(line, event_list)
+        finally:
+            sys.monitoring.set_events(tool, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+    @staticmethod
+    def func1():
+        line1 = 1
+
+    MUST_INCLUDE_LI = [
+            ('instruction', 'func1', 2),
+            ('line', 'func1', 2),
+            ('instruction', 'func1', 4),
+            ('instruction', 'func1', 6)]
+
+    def test_line_then_instruction(self):
+        recorders = [ LineRecorder, InstructionRecorder ]
+        self.check_events(self.func1,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_LI)
+
+    def test_instruction_then_line(self):
+        recorders = [ InstructionRecorder, LineRecorder ]
+        self.check_events(self.func1,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_LI)
+
+    @staticmethod
+    def func2():
+        len(())
+
+    MUST_INCLUDE_CI = [
+            ('instruction', 'func2', 2),
+            ('call', 'func2', sys.monitoring.MISSING),
+            ('call', 'len', ()),
+            ('instruction', 'func2', 12),
+            ('instruction', 'func2', 14)]
+
+
+
+    def test_call_then_instruction(self):
+        recorders = [ CallRecorder, InstructionRecorder ]
+        self.check_events(self.func2,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_CI)
+
+    def test_instruction_then_call(self):
+        recorders = [ InstructionRecorder, CallRecorder ]
+        self.check_events(self.func2,
+                          recorders = recorders, must_include = self.MUST_INCLUDE_CI)
+
+LOCAL_RECORDERS = CallRecorder, LineRecorder, CReturnRecorder, CRaiseRecorder
+
+class TestLocalEvents(MonitoringTestBase, unittest.TestCase):
+
+    def check_events(self, func, expected, tool=TEST_TOOL, recorders=()):
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                ev = recorder.event_type
+                sys.monitoring.register_callback(tool, ev, recorder(event_list))
+                all_events |= ev
+            sys.monitoring.set_local_events(tool, func.__code__, all_events)
+            func()
+            sys.monitoring.set_local_events(tool, func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            self.assertEqual(event_list, expected)
+        finally:
+            sys.monitoring.set_local_events(tool, func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+
+    def test_simple(self):
+
+        def func1():
+            line1 = 1
+            line2 = 2
+            line3 = 3
+
+        self.check_events(func1, recorders = LOCAL_RECORDERS, expected = [
+            ('line', 'func1', 1),
+            ('line', 'func1', 2),
+            ('line', 'func1', 3)])
+
+    def test_c_call(self):
+
+        def func2():
+            line1 = 1
+            [].append(2)
+            line3 = 3
+
+        self.check_events(func2, recorders = LOCAL_RECORDERS, expected = [
+            ('line', 'func2', 1),
+            ('line', 'func2', 2),
+            ('call', 'append', [2]),
+            ('C return', 'append', [2]),
+            ('line', 'func2', 3)])
+
+    def test_try_except(self):
+
+        def func3():
+            try:
+                line = 2
+                raise KeyError
+            except:
+                line = 5
+            line = 6
+
+        self.check_events(func3, recorders = LOCAL_RECORDERS, expected = [
+            ('line', 'func3', 1),
+            ('line', 'func3', 2),
+            ('line', 'func3', 3),
+            ('line', 'func3', 4),
+            ('line', 'func3', 5),
+            ('line', 'func3', 6)])
+
+    def test_set_non_local_event(self):
+        with self.assertRaises(ValueError):
+            sys.monitoring.set_local_events(TEST_TOOL, just_call.__code__, E.RAISE)
+
+def line_from_offset(code, offset):
+    for start, end, line in code.co_lines():
+        if start <= offset < end:
+            if line is None:
+                return f"[offset={offset}]"
+            return line - code.co_firstlineno
+    return -1
+
+class JumpRecorder:
+
+    event_type = E.JUMP
+    name = "jump"
+
+    def __init__(self, events):
+        self.events = events
+
+    def __call__(self, code, from_, to):
+        from_line = line_from_offset(code, from_)
+        to_line = line_from_offset(code, to)
+        self.events.append((self.name, code.co_name, from_line, to_line))
+
+
+class BranchRecorder(JumpRecorder):
+
+    event_type = E.BRANCH
+    name = "branch"
+
+class BranchRightRecorder(JumpRecorder):
+
+    event_type = E.BRANCH_RIGHT
+    name = "branch right"
+
+class BranchLeftRecorder(JumpRecorder):
+
+    event_type = E.BRANCH_LEFT
+    name = "branch left"
+
+class JumpOffsetRecorder:
+
+    event_type = E.JUMP
+    name = "jump"
+
+    def __init__(self, events, offsets=False):
+        self.events = events
+
+    def __call__(self, code, from_, to):
+        self.events.append((self.name, code.co_name, from_, to))
+
+class BranchLeftOffsetRecorder(JumpOffsetRecorder):
+
+    event_type = E.BRANCH_LEFT
+    name = "branch left"
+
+class BranchRightOffsetRecorder(JumpOffsetRecorder):
+
+    event_type = E.BRANCH_RIGHT
+    name = "branch right"
+
+
+JUMP_AND_BRANCH_RECORDERS = JumpRecorder, BranchRecorder
+JUMP_BRANCH_AND_LINE_RECORDERS = JumpRecorder, BranchRecorder, LineRecorder
+FLOW_AND_LINE_RECORDERS = JumpRecorder, BranchRecorder, LineRecorder, ExceptionRecorder, ReturnRecorder
+
+BRANCHES_RECORDERS = BranchLeftRecorder, BranchRightRecorder
+BRANCH_OFFSET_RECORDERS = BranchLeftOffsetRecorder, BranchRightOffsetRecorder
+
+class TestBranchAndJumpEvents(CheckEvents):
+    maxDiff = None
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_loop(self):
+
+        def func():
+            x = 1
+            for a in range(2):
+                if a:
+                    x = 4
+                else:
+                    x = 6
+            7
+
+        def whilefunc(n=0):
+            while n < 3:
+                n += 1 # line 2
+            3
+
+        self.check_events(func, recorders = JUMP_AND_BRANCH_RECORDERS, expected = [
+            ('branch', 'func', 2, 2),
+            ('branch', 'func', 3, 6),
+            ('jump', 'func', 6, 2),
+            ('branch', 'func', 2, 2),
+            ('branch', 'func', 3, 4),
+            ('jump', 'func', 4, 2),
+            ('branch', 'func', 2, 7)])
+
+        self.check_events(func, recorders = JUMP_BRANCH_AND_LINE_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func', 1),
+            ('line', 'func', 2),
+            ('branch', 'func', 2, 2),
+            ('line', 'func', 3),
+            ('branch', 'func', 3, 6),
+            ('line', 'func', 6),
+            ('jump', 'func', 6, 2),
+            ('line', 'func', 2),
+            ('branch', 'func', 2, 2),
+            ('line', 'func', 3),
+            ('branch', 'func', 3, 4),
+            ('line', 'func', 4),
+            ('jump', 'func', 4, 2),
+            ('line', 'func', 2),
+            ('branch', 'func', 2, 7),
+            ('line', 'func', 7),
+            ('line', 'get_events', 11)])
+
+        self.check_events(func, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 3, 6),
+            ('branch left', 'func', 2, 2),
+            ('branch left', 'func', 3, 4),
+            ('branch right', 'func', 2, 7)])
+
+        self.check_events(whilefunc, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'whilefunc', 1, 2),
+            ('branch left', 'whilefunc', 1, 2),
+            ('branch left', 'whilefunc', 1, 2),
+            ('branch right', 'whilefunc', 1, 3)])
+
+        self.check_events(func, recorders = BRANCH_OFFSET_RECORDERS, expected = [
+            ('branch left', 'func', 28, 32),
+            ('branch right', 'func', 44, 58),
+            ('branch left', 'func', 28, 32),
+            ('branch left', 'func', 44, 50),
+            ('branch right', 'func', 28, 70)])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_except_star(self):
+
+        class Foo:
+            def meth(self):
+                pass
+
+        def func():
+            try:
+                try:
+                    raise KeyError
+                except* Exception as e:
+                    f = Foo(); f.meth()
+            except KeyError:
+                pass
+
+
+        self.check_events(func, recorders = JUMP_BRANCH_AND_LINE_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func', 1),
+            ('line', 'func', 2),
+            ('line', 'func', 3),
+            ('line', 'func', 4),
+            ('branch', 'func', 4, 4),
+            ('line', 'func', 5),
+            ('line', 'meth', 1),
+            ('jump', 'func', 5, '[offset=120]'),
+            ('branch', 'func', '[offset=124]', '[offset=130]'),
+            ('line', 'get_events', 11)])
+
+        self.check_events(func, recorders = FLOW_AND_LINE_RECORDERS, expected = [
+            ('line', 'get_events', 10),
+            ('line', 'func', 1),
+            ('line', 'func', 2),
+            ('line', 'func', 3),
+            ('raise', KeyError),
+            ('line', 'func', 4),
+            ('branch', 'func', 4, 4),
+            ('line', 'func', 5),
+            ('line', 'meth', 1),
+            ('return', 'meth', None),
+            ('jump', 'func', 5, '[offset=120]'),
+            ('branch', 'func', '[offset=124]', '[offset=130]'),
+            ('return', 'func', None),
+            ('line', 'get_events', 11)])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_while_offset_consistency(self):
+
+        def foo(n=0):
+            while n<4:
+                pass
+                n += 1
+            return None
+
+        in_loop = ('branch left', 'foo', 10, 16)
+        exit_loop = ('branch right', 'foo', 10, 40)
+        self.check_events(foo, recorders = BRANCH_OFFSET_RECORDERS, expected = [
+            in_loop,
+            in_loop,
+            in_loop,
+            in_loop,
+            exit_loop])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_async_for(self):
+
+        def func():
+            async def gen():
+                yield 2
+                yield 3
+
+            async def foo():
+                async for y in gen():
+                    2
+                pass # line 3
+
+            try:
+                foo().send(None)
+            except StopIteration:
+                pass
+
+        self.check_events(func, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'foo', 1, 1),
+            ('branch left', 'foo', 1, 1),
+            ('branch right', 'foo', 1, 3),
+            ('branch left', 'func', 12, 12)])
+
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - bytecode layout differs from CPython
+    def test_match(self):
+
+        def func(v=1):
+            x = 0
+            for v in range(4):
+                match v:
+                    case 1:
+                        x += 1
+                    case 2:
+                        x += 2
+                    case _:
+                        x += 3
+            return x
+
+        self.check_events(func, recorders = BRANCHES_RECORDERS, expected = [
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 4, 6),
+            ('branch right', 'func', 6, 8),
+            ('branch left', 'func', 2, 2),
+            ('branch left', 'func', 4, 5),
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 4, 6),
+            ('branch left', 'func', 6, 7),
+            ('branch left', 'func', 2, 2),
+            ('branch right', 'func', 4, 6),
+            ('branch right', 'func', 6, 8),
+            ('branch right', 'func', 2, 10)])
+
+    def test_callback_set_frame_lineno(self):
+        def func(s: str) -> int:
+            if s.startswith("t"):
+                return 1
+            else:
+                return 0
+
+        def callback(code, from_, to):
+            # try set frame.f_lineno
+            frame = inspect.currentframe()
+            while frame and frame.f_code is not code:
+                frame = frame.f_back
+
+            self.assertIsNotNone(frame)
+            frame.f_lineno = frame.f_lineno + 1 # run next instruction
+
+        sys.monitoring.set_local_events(TEST_TOOL, func.__code__, E.BRANCH_LEFT)
+        sys.monitoring.register_callback(TEST_TOOL, E.BRANCH_LEFT, callback)
+
+        self.assertEqual(func("true"), 1)
+
+
+class TestBranchConsistency(MonitoringTestBase, unittest.TestCase):
+
+    def check_branches(self, run_func, test_func=None, tool=TEST_TOOL, recorders=BRANCH_OFFSET_RECORDERS):
+        if test_func is None:
+            test_func = run_func
+        try:
+            self.assertEqual(sys.monitoring._all_events(), {})
+            event_list = []
+            all_events = 0
+            for recorder in recorders:
+                ev = recorder.event_type
+                sys.monitoring.register_callback(tool, ev, recorder(event_list))
+                all_events |= ev
+            sys.monitoring.set_local_events(tool, test_func.__code__, all_events)
+            run_func()
+            sys.monitoring.set_local_events(tool, test_func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+            lefts = set()
+            rights = set()
+            for (src, left, right) in test_func.__code__.co_branches():
+                lefts.add((src, left))
+                rights.add((src, right))
+            for event in event_list:
+                way, _, src, dest = event
+                if "left" in way:
+                    self.assertIn((src, dest), lefts)
+                else:
+                    self.assertIn("right", way)
+                    self.assertIn((src, dest), rights)
+        finally:
+            sys.monitoring.set_local_events(tool, test_func.__code__, 0)
+            for recorder in recorders:
+                sys.monitoring.register_callback(tool, recorder.event_type, None)
+
+    def test_simple(self):
+
+        def func():
+            x = 1
+            for a in range(2):
+                if a:
+                    x = 4
+                else:
+                    x = 6
+            7
+
+        self.check_branches(func)
+
+        def whilefunc(n=0):
+            while n < 3:
+                n += 1 # line 2
+            3
+
+        self.check_branches(whilefunc)
+
+    def test_except_star(self):
+
+        class Foo:
+            def meth(self):
+                pass
+
+        def func():
+            try:
+                try:
+                    raise KeyError
+                except* Exception as e:
+                    f = Foo(); f.meth()
+            except KeyError:
+                pass
+
+
+        self.check_branches(func)
+
+    def test4(self):
+
+        def foo(n=0):
+            while n<4:
+                pass
+                n += 1
+            return None
+
+        self.check_branches(foo)
+
+    def test_async_for(self):
+
+        async def gen():
+            yield 2
+            yield 3
+
+        async def foo():
+            async for y in gen():
+                2
+            pass # line 3
+
+        def func():
+            try:
+                foo().send(None)
+            except StopIteration:
+                pass
+
+        self.check_branches(func, foo)
+
+
+class TestLoadSuperAttr(CheckEvents):
+    RECORDERS = CallRecorder, LineRecorder, CRaiseRecorder, CReturnRecorder
+
+    def _exec(self, co):
+        d = {}
+        exec(co, d, d)
+        return d
+
+    def _exec_super(self, codestr, optimized=False):
+        # The compiler checks for statically visible shadowing of the name
+        # `super`, and declines to emit `LOAD_SUPER_ATTR` if shadowing is found.
+        # So inserting `super = super` prevents the compiler from emitting
+        # `LOAD_SUPER_ATTR`, and allows us to test that monitoring events for
+        # `LOAD_SUPER_ATTR` are equivalent to those we'd get from the
+        # un-optimized `LOAD_GLOBAL super; CALL; LOAD_ATTR` form.
+        assignment = "x = 1" if optimized else "super = super"
+        codestr = f"{assignment}\n{textwrap.dedent(codestr)}"
+        co = compile(codestr, "<string>", "exec")
+        # validate that we really do have a LOAD_SUPER_ATTR, only when optimized
+        self.assertEqual(self._has_load_super_attr(co), optimized)
+        return self._exec(co)
+
+    def _has_load_super_attr(self, co):
+        has = any(instr.opname == "LOAD_SUPER_ATTR" for instr in dis.get_instructions(co))
+        if not has:
+            has = any(
+                isinstance(c, types.CodeType) and self._has_load_super_attr(c)
+                for c in co.co_consts
+            )
+        return has
+
+    def _super_method_call(self, optimized=False):
+        codestr = """
+            class A:
+                def method(self, x):
+                    return x
+
+            class B(A):
+                def method(self, x):
+                    return super(
+                    ).method(
+                        x
+                    )
+
+            b = B()
+            def f():
+                return b.method(1)
+        """
+        d = self._exec_super(codestr, optimized)
+        expected = [
+            ('line', 'get_events', 10),
+            ('call', 'f', sys.monitoring.MISSING),
+            ('line', 'f', 1),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('call', 'super', sys.monitoring.MISSING),
+            ('C return', 'super', sys.monitoring.MISSING),
+            ('line', 'method', 2),
+            ('line', 'method', 3),
+            ('line', 'method', 2),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('line', 'method', 1),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2),
+        ]
+        return d["f"], expected
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_method_call(self):
+        nonopt_func, nonopt_expected = self._super_method_call(optimized=False)
+        opt_func, opt_expected = self._super_method_call(optimized=True)
+
+        self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
+        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)
+
+    def _super_method_call_error(self, optimized=False):
+        codestr = """
+            class A:
+                def method(self, x):
+                    return x
+
+            class B(A):
+                def method(self, x):
+                    return super(
+                        x,
+                        self,
+                    ).method(
+                        x
+                    )
+
+            b = B()
+            def f():
+                try:
+                    return b.method(1)
+                except TypeError:
+                    pass
+                else:
+                    assert False, "should have raised TypeError"
+        """
+        d = self._exec_super(codestr, optimized)
+        expected = [
+            ('line', 'get_events', 10),
+            ('call', 'f', sys.monitoring.MISSING),
+            ('line', 'f', 1),
+            ('line', 'f', 2),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('line', 'method', 2),
+            ('line', 'method', 3),
+            ('line', 'method', 1),
+            ('call', 'super', 1),
+            ('C raise', 'super', 1),
+            ('line', 'f', 3),
+            ('line', 'f', 4),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2),
+        ]
+        return d["f"], expected
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_method_call_error(self):
+        nonopt_func, nonopt_expected = self._super_method_call_error(optimized=False)
+        opt_func, opt_expected = self._super_method_call_error(optimized=True)
+
+        self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
+        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)
+
+    def _super_attr(self, optimized=False):
+        codestr = """
+            class A:
+                x = 1
+
+            class B(A):
+                def method(self):
+                    return super(
+                    ).x
+
+            b = B()
+            def f():
+                return b.method()
+        """
+        d = self._exec_super(codestr, optimized)
+        expected = [
+            ('line', 'get_events', 10),
+            ('call', 'f', sys.monitoring.MISSING),
+            ('line', 'f', 1),
+            ('call', 'method', d["b"]),
+            ('line', 'method', 1),
+            ('call', 'super', sys.monitoring.MISSING),
+            ('C return', 'super', sys.monitoring.MISSING),
+            ('line', 'method', 2),
+            ('line', 'method', 1),
+            ('line', 'get_events', 11),
+            ('call', 'set_events', 2)
+        ]
+        return d["f"], expected
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_attr(self):
+        nonopt_func, nonopt_expected = self._super_attr(optimized=False)
+        opt_func, opt_expected = self._super_attr(optimized=True)
+
+        self.check_events(nonopt_func, recorders=self.RECORDERS, expected=nonopt_expected)
+        self.check_events(opt_func, recorders=self.RECORDERS, expected=opt_expected)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; line number differences in multi-line super() calls
+    def test_vs_other_type_call(self):
+        code_template = textwrap.dedent("""
+            class C:
+                def method(self):
+                    return {cls}().__repr__{call}
+            c = C()
+            def f():
+                return c.method()
+        """)
+
+        def get_expected(name, call_method, ns):
+            repr_arg = 0 if name == "int" else sys.monitoring.MISSING
+            return [
+                ('line', 'get_events', 10),
+                ('call', 'f', sys.monitoring.MISSING),
+                ('line', 'f', 1),
+                ('call', 'method', ns["c"]),
+                ('line', 'method', 1),
+                ('call', name, sys.monitoring.MISSING),
+                ('C return', name, sys.monitoring.MISSING),
+                *(
+                    [
+                        ('call', '__repr__', repr_arg),
+                        ('C return', '__repr__', repr_arg),
+                    ] if call_method else []
+                ),
+                ('line', 'get_events', 11),
+                ('call', 'set_events', 2),
+            ]
+
+        for call_method in [True, False]:
+            with self.subTest(call_method=call_method):
+                call_str = "()" if call_method else ""
+                code_super = code_template.format(cls="super", call=call_str)
+                code_int = code_template.format(cls="int", call=call_str)
+                co_super = compile(code_super, '<string>', 'exec')
+                self.assertTrue(self._has_load_super_attr(co_super))
+                ns_super = self._exec(co_super)
+                ns_int = self._exec(code_int)
+
+                self.check_events(
+                    ns_super["f"],
+                    recorders=self.RECORDERS,
+                    expected=get_expected("super", call_method, ns_super)
+                )
+                self.check_events(
+                    ns_int["f"],
+                    recorders=self.RECORDERS,
+                    expected=get_expected("int", call_method, ns_int)
+                )
+
+
+class TestSetGetEvents(MonitoringTestBase, unittest.TestCase):
+
+    def test_global(self):
+        sys.monitoring.set_events(TEST_TOOL, E.PY_START)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), E.PY_START)
+        sys.monitoring.set_events(TEST_TOOL2, E.PY_START)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), E.PY_START)
+        sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL), 0)
+        sys.monitoring.set_events(TEST_TOOL2,0)
+        self.assertEqual(sys.monitoring.get_events(TEST_TOOL2), 0)
+
+    def test_local(self):
+        code = f1.__code__
+        sys.monitoring.set_local_events(TEST_TOOL, code, E.PY_START)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), E.PY_START)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        sys.monitoring.set_local_events(TEST_TOOL, code, E.BRANCH)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), E.BRANCH_LEFT | E.BRANCH_RIGHT)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        sys.monitoring.set_local_events(TEST_TOOL2, code, E.PY_START)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL2, code), E.PY_START)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), 0)
+        sys.monitoring.set_local_events(TEST_TOOL2, code, 0)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL2, code), 0)
+
+class TestUninitialized(unittest.TestCase, MonitoringTestBase):
+
+    @staticmethod
+    def f():
+        pass
+
+    def test_get_local_events_uninitialized(self):
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, self.f.__code__), 0)
+
+class TestRegressions(MonitoringTestBase, unittest.TestCase):
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; + inner
+    def test_105162(self):
+        caught = None
+
+        def inner():
+            nonlocal caught
+            try:
+                yield
+            except Exception:
+                caught = "inner"
+                yield
+
+        def outer():
+            nonlocal caught
+            try:
+                yield from inner()
+            except Exception:
+                caught = "outer"
+                yield
+
+        def run():
+            gen = outer()
+            gen.send(None)
+            gen.throw(Exception)
+        run()
+        self.assertEqual(caught, "inner")
+        caught = None
+        try:
+            sys.monitoring.set_events(TEST_TOOL, E.PY_RESUME)
+            run()
+            self.assertEqual(caught, "inner")
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    def test_108390(self):
+
+        class Foo:
+            def __init__(self, set_event):
+                if set_event:
+                    sys.monitoring.set_events(TEST_TOOL, E.PY_RESUME)
+
+        def make_foo_optimized_then_set_event():
+            for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD + 1):
+                Foo(i == _testinternalcapi.SPECIALIZATION_THRESHOLD)
+
+        try:
+            make_foo_optimized_then_set_event()
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_gh108976(self):
+        sys.monitoring.use_tool_id(0, "test")
+        self.addCleanup(sys.monitoring.free_tool_id, 0)
+        sys.monitoring.set_events(0, 0)
+        sys.monitoring.register_callback(0, E.LINE, lambda *args: sys.monitoring.set_events(0, 0))
+        sys.monitoring.register_callback(0, E.INSTRUCTION, lambda *args: 0)
+        sys.monitoring.set_events(0, E.LINE | E.INSTRUCTION)
+        sys.monitoring.set_events(0, 0)
+
+    def test_call_function_ex(self):
+        def f(a=1, b=2):
+            return a + b
+        args = (1, 2)
+        empty_args = []
+
+        call_data = []
+        sys.monitoring.use_tool_id(0, "test")
+        self.addCleanup(sys.monitoring.free_tool_id, 0)
+        sys.monitoring.set_events(0, 0)
+        sys.monitoring.register_callback(0, E.CALL, lambda code, offset, callable, arg0: call_data.append((callable, arg0)))
+        sys.monitoring.set_events(0, E.CALL)
+        f(*args)
+        f(*empty_args)
+        sys.monitoring.set_events(0, 0)
+        self.assertEqual(call_data[0], (f, 1))
+        self.assertEqual(call_data[1], (f, sys.monitoring.MISSING))
+
+    def test_instruction_explicit_callback(self):
+        # gh-122247
+        # Calling the instruction event callback explicitly should not
+        # crash CPython
+        def callback(code, instruction_offset):
+            pass
+
+        sys.monitoring.use_tool_id(0, "test")
+        self.addCleanup(sys.monitoring.free_tool_id, 0)
+        sys.monitoring.register_callback(0, sys.monitoring.events.INSTRUCTION, callback)
+        sys.monitoring.set_events(0, sys.monitoring.events.INSTRUCTION)
+        callback(None, 0)  # call the *same* handler while it is registered
+        sys.monitoring.restart_events()
+        sys.monitoring.set_events(0, 0)
+
+
+class TestOptimizer(MonitoringTestBase, unittest.TestCase):
+
+    def test_for_loop(self):
+        def test_func(x):
+            i = 0
+            while i < x:
+                i += 1
+
+        code = test_func.__code__
+        sys.monitoring.set_local_events(TEST_TOOL, code, E.PY_START)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), E.PY_START)
+        test_func(1000)
+        sys.monitoring.set_local_events(TEST_TOOL, code, 0)
+        self.assertEqual(sys.monitoring.get_local_events(TEST_TOOL, code), 0)
+
+class TestTier2Optimizer(CheckEvents):
+
+    @unittest.skipUnless(_testinternalcapi, "requires _testinternalcapi")
+    def test_monitoring_already_opimized_loop(self):
+        def test_func(recorder):
+            set_events = sys.monitoring.set_events
+            line = E.LINE
+            i = 0
+            for i in range(_testinternalcapi.SPECIALIZATION_THRESHOLD + 51):
+                # Turn on events without branching once i reaches _testinternalcapi.SPECIALIZATION_THRESHOLD.
+                set_events(TEST_TOOL, line * int(i >= _testinternalcapi.SPECIALIZATION_THRESHOLD))
+                pass
+                pass
+                pass
+
+        self.assertEqual(sys.monitoring._all_events(), {})
+        events = []
+        recorder = LineRecorder(events)
+        sys.monitoring.register_callback(TEST_TOOL, E.LINE, recorder)
+        try:
+            test_func(recorder)
+        finally:
+            sys.monitoring.register_callback(TEST_TOOL, E.LINE, None)
+            sys.monitoring.set_events(TEST_TOOL, 0)
+        self.assertGreater(len(events), 250)
+
+class TestMonitoringAtShutdown(unittest.TestCase):
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; - requires subprocess support
+    def test_monitoring_live_at_shutdown(self):
+        # gh-115832: An object destructor running during the final GC of
+        # interpreter shutdown triggered an infinite loop in the
+        # instrumentation code.
+        script = test.support.findfile("_test_monitoring_shutdown.py")
+        script_helper.run_test_script(script)
+
+
+@unittest.skipUnless(_testcapi, "requires _testcapi")
+class TestCApiEventGeneration(MonitoringTestBase, unittest.TestCase):
+
+    class Scope:
+        def __init__(self, *args):
+            self.args = args
+
+        def __enter__(self):
+            _testcapi.monitoring_enter_scope(*self.args)
+
+        def __exit__(self, *args):
+            _testcapi.monitoring_exit_scope()
+
+    def setUp(self):
+        super(TestCApiEventGeneration, self).setUp()
+
+        capi = _testcapi
+
+        self.codelike = capi.CodeLike(2)
+
+        self.cases = [
+            # (Event, function, *args)
+            ( 1, E.PY_START, capi.fire_event_py_start),
+            ( 1, E.PY_RESUME, capi.fire_event_py_resume),
+            ( 1, E.PY_YIELD, capi.fire_event_py_yield, 10),
+            ( 1, E.PY_RETURN, capi.fire_event_py_return, 20),
+            ( 2, E.CALL, capi.fire_event_call, callable, 40),
+            ( 1, E.JUMP, capi.fire_event_jump, 60),
+            ( 1, E.BRANCH_RIGHT, capi.fire_event_branch_right, 70),
+            ( 1, E.BRANCH_LEFT, capi.fire_event_branch_left, 80),
+            ( 1, E.PY_THROW, capi.fire_event_py_throw, ValueError(1)),
+            ( 1, E.RAISE, capi.fire_event_raise, ValueError(2)),
+            ( 1, E.EXCEPTION_HANDLED, capi.fire_event_exception_handled, ValueError(5)),
+            ( 1, E.PY_UNWIND, capi.fire_event_py_unwind, ValueError(6)),
+            ( 1, E.STOP_ITERATION, capi.fire_event_stop_iteration, 7),
+            ( 1, E.STOP_ITERATION, capi.fire_event_stop_iteration, StopIteration(8)),
+        ]
+
+        self.EXPECT_RAISED_EXCEPTION = [E.PY_THROW, E.RAISE, E.EXCEPTION_HANDLED, E.PY_UNWIND]
+
+
+    def check_event_count(self, event, func, args, expected, callback_raises=None):
+        class Counter:
+            def __init__(self, callback_raises):
+                self.callback_raises = callback_raises
+                self.count = 0
+
+            def __call__(self, *args):
+                self.count += 1
+                if self.callback_raises:
+                    exc = self.callback_raises
+                    self.callback_raises = None
+                    raise exc
+
+        try:
+            counter = Counter(callback_raises)
+            sys.monitoring.register_callback(TEST_TOOL, event, counter)
+            if event == E.C_RETURN or event == E.C_RAISE:
+                sys.monitoring.set_events(TEST_TOOL, E.CALL)
+            else:
+                sys.monitoring.set_events(TEST_TOOL, event)
+            event_value = int(math.log2(event))
+            with self.Scope(self.codelike, event_value):
+                counter.count = 0
+                try:
+                    func(*args)
+                except ValueError as e:
+                    self.assertIsInstance(expected, ValueError)
+                    self.assertEqual(str(e), str(expected))
+                    return
+                else:
+                    self.assertEqual(counter.count, expected)
+
+            prev = sys.monitoring.register_callback(TEST_TOOL, event, None)
+            with self.Scope(self.codelike, event_value):
+                counter.count = 0
+                func(*args)
+                self.assertEqual(counter.count, 0)
+                self.assertEqual(prev, counter)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_fire_event(self):
+        for expected, event, function, *args in self.cases:
+            offset = 0
+            self.codelike = _testcapi.CodeLike(1)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, offset) + tuple(args)
+                self.check_event_count(event, function, args_, expected)
+
+    def test_missing_exception(self):
+        for _, event, function, *args in self.cases:
+            if event not in self.EXPECT_RAISED_EXCEPTION:
+                continue
+            assert args and isinstance(args[-1], BaseException)
+            offset = 0
+            self.codelike = _testcapi.CodeLike(1)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, offset) + tuple(args[:-1]) + (None,)
+                evt = int(math.log2(event))
+                expected = ValueError(f"Firing event {evt} with no exception set")
+                self.check_event_count(event, function, args_, expected)
+
+    def test_fire_event_failing_callback(self):
+        for expected, event, function, *args in self.cases:
+            offset = 0
+            self.codelike = _testcapi.CodeLike(1)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, offset) + tuple(args)
+                exc = OSError(42)
+                with self.assertRaises(type(exc)):
+                    self.check_event_count(event, function, args_, expected,
+                                           callback_raises=exc)
+
+
+    CANNOT_DISABLE = { E.PY_THROW, E.RAISE, E.RERAISE,
+                       E.EXCEPTION_HANDLED, E.PY_UNWIND }
+
+    def check_disable(self, event, func, args, expected):
+        try:
+            counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, event, counter)
+            if event == E.C_RETURN or event == E.C_RAISE:
+                sys.monitoring.set_events(TEST_TOOL, E.CALL)
+            else:
+                sys.monitoring.set_events(TEST_TOOL, event)
+            event_value = int(math.log2(event))
+            with self.Scope(self.codelike, event_value):
+                counter.count = 0
+                func(*args)
+                self.assertEqual(counter.count, expected)
+                counter.disable = True
+                if event in self.CANNOT_DISABLE:
+                    # use try-except rather then assertRaises to avoid
+                    # events from framework code
+                    try:
+                        counter.count = 0
+                        func(*args)
+                        self.assertEqual(counter.count, expected)
+                    except ValueError:
+                        pass
+                    else:
+                        self.Error("Expected a ValueError")
+                else:
+                    counter.count = 0
+                    func(*args)
+                    self.assertEqual(counter.count, expected)
+                    counter.count = 0
+                    func(*args)
+                    self.assertEqual(counter.count, expected - 1)
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
+
+    def test_disable_event(self):
+        for expected, event, function, *args in self.cases:
+            offset = 0
+            self.codelike = _testcapi.CodeLike(2)
+            with self.subTest(function.__name__):
+                args_ = (self.codelike, 0) + tuple(args)
+                self.check_disable(event, function, args_, expected)
+
+    def test_enter_scope_two_events(self):
+        try:
+            yield_counter = CounterWithDisable()
+            unwind_counter = CounterWithDisable()
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_YIELD, yield_counter)
+            sys.monitoring.register_callback(TEST_TOOL, E.PY_UNWIND, unwind_counter)
+            sys.monitoring.set_events(TEST_TOOL, E.PY_YIELD | E.PY_UNWIND)
+
+            yield_value = int(math.log2(E.PY_YIELD))
+            unwind_value = int(math.log2(E.PY_UNWIND))
+            cl = _testcapi.CodeLike(2)
+            common_args = (cl, 0)
+            with self.Scope(cl, yield_value, unwind_value):
+                yield_counter.count = 0
+                unwind_counter.count = 0
+
+                _testcapi.fire_event_py_unwind(*common_args, ValueError(42))
+                assert(yield_counter.count == 0)
+                assert(unwind_counter.count == 1)
+
+                _testcapi.fire_event_py_yield(*common_args, ValueError(42))
+                assert(yield_counter.count == 1)
+                assert(unwind_counter.count == 1)
+
+                yield_counter.disable = True
+                _testcapi.fire_event_py_yield(*common_args, ValueError(42))
+                assert(yield_counter.count == 2)
+                assert(unwind_counter.count == 1)
+
+                _testcapi.fire_event_py_yield(*common_args, ValueError(42))
+                assert(yield_counter.count == 2)
+                assert(unwind_counter.count == 1)
+
+        finally:
+            sys.monitoring.set_events(TEST_TOOL, 0)
diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
index 3f12ce135af..26d3507c679 100644
--- a/Lib/test/test_peepholer.py
+++ b/Lib/test/test_peepholer.py
@@ -82,7 +82,6 @@ def check_lnotab(self, code):
         # aren't very many tests of lnotab), if peepholer wasn't scheduled
         # to be replaced anyway.
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; RETURN_VALUE
     def test_unot(self):
         # UNARY_NOT POP_JUMP_IF_FALSE  -->  POP_JUMP_IF_TRUE'
         def unot(x):
@@ -283,7 +282,7 @@ def test_constant_folding_small_int(self):
                     self.assertNotInBytecode(code, 'LOAD_SMALL_INT')
                 self.check_lnotab(code)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; AssertionError: 'UNARY_NEGATIVE' starts with 'UNARY_'
     def test_constant_folding_unaryop(self):
         intrinsic_positive = 5
         tests = [
@@ -546,6 +545,7 @@ def f(cond, true_value, false_value):
         self.assertEqual(len(returns), 2)
         self.check_lnotab(f)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; absolute jump encoding
     def test_elim_jump_to_uncond_jump(self):
         # POP_JUMP_IF_FALSE to JUMP_FORWARD --> POP_JUMP_IF_FALSE to non-jump
         def f():
@@ -640,12 +640,14 @@ def g()->1+1:
         self.assertNotInBytecode(f, 'BINARY_OP')
         self.check_lnotab(f)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; no BUILD_LIST to BUILD_TUPLE optimization
     def test_in_literal_list(self):
         def containtest():
             return x in [a, b]
         self.assertEqual(count_instr_recursively(containtest, 'BUILD_LIST'), 0)
         self.check_lnotab(containtest)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; no BUILD_LIST to BUILD_TUPLE optimization
     def test_iterate_literal_list(self):
         def forloop():
             for x in [a, b]:
@@ -887,7 +889,6 @@ def f():
         self.assertInBytecode(f, 'LOAD_FAST_CHECK')
         self.assertNotInBytecode(f, 'LOAD_FAST')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; RETURN_VALUE
     def test_load_fast_known_because_parameter(self):
         def f1(x):
             print(x)
@@ -924,7 +925,6 @@ def f():
         self.assertInBytecode(f, 'LOAD_FAST_CHECK')
         self.assertInBytecode(f, 'LOAD_FAST_BORROW')
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; RETURN_VALUE
     def test_load_fast_known_multiple_branches(self):
         def f():
             if condition():
diff --git a/Lib/test/test_sys_settrace.py b/Lib/test/test_sys_settrace.py
index a1e4b091a1d..65193d4f8c8 100644
--- a/Lib/test/test_sys_settrace.py
+++ b/Lib/test/test_sys_settrace.py
@@ -1393,23 +1393,17 @@ def test(self):
 
     ## The first set of 'jump' tests are for things that are allowed:
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 3, [3])
     def test_jump_simple_forwards(output):
         output.append(1)
         output.append(2)
         output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 1, [1, 1, 2])
     def test_jump_simple_backwards(output):
         output.append(1)
         output.append(2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 5, [2, 5])
     def test_jump_out_of_block_forwards(output):
         for i in 1, 2:
@@ -1418,8 +1412,6 @@ def test_jump_out_of_block_forwards(output):
                 output.append(4)
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(6, 1, [1, 3, 5, 1, 3, 5, 6, 7])
     def test_jump_out_of_block_backwards(output):
         output.append(1)
@@ -1451,8 +1443,6 @@ async def test_jump_out_of_async_for_block_backwards(output):
                 output.append(5)
             output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 2, [3])
     def test_jump_to_codeless_line(output):
         output.append(1)
@@ -1465,8 +1455,6 @@ def test_jump_to_same_line(output):
         output.append(2)
         output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Tests jumping within a finally block, and over one.
     @jump_test(4, 9, [2, 9])
     def test_jump_in_nested_finally(output):
@@ -1480,8 +1468,6 @@ def test_jump_in_nested_finally(output):
                 output.append(8)
             output.append(9)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(6, 7, [2, 7], (ZeroDivisionError, ''))
     def test_jump_in_nested_finally_2(output):
         try:
@@ -1493,8 +1479,6 @@ def test_jump_in_nested_finally_2(output):
             output.append(7)
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(6, 11, [2, 11], (ZeroDivisionError, ''))
     def test_jump_in_nested_finally_3(output):
         try:
@@ -1535,8 +1519,6 @@ def test_no_jump_infinite_while_loop(output):
             output.append(3)
         output.append(4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 4, [4, 4])
     def test_jump_forwards_into_while_block(output):
         i = 1
@@ -1545,8 +1527,6 @@ def test_jump_forwards_into_while_block(output):
             output.append(4)
             i += 1
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 3, [3, 3, 3, 5])
     def test_jump_backwards_into_while_block(output):
         i = 1
@@ -1555,8 +1535,6 @@ def test_jump_backwards_into_while_block(output):
             i += 1
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 3, [1, 3])
     def test_jump_forwards_out_of_with_block(output):
         with tracecontext(output, 1):
@@ -1571,8 +1549,6 @@ async def test_jump_forwards_out_of_async_with_block(output):
             output.append(2)
         output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 1, [1, 2, 1, 2, 3, -2])
     def test_jump_backwards_out_of_with_block(output):
         output.append(1)
@@ -1587,8 +1563,6 @@ async def test_jump_backwards_out_of_async_with_block(output):
         async with asynctracecontext(output, 2):
             output.append(3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 5, [5])
     def test_jump_forwards_out_of_try_finally_block(output):
         try:
@@ -1597,8 +1571,6 @@ def test_jump_forwards_out_of_try_finally_block(output):
             output.append(4)
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 1, [1, 1, 3, 5])
     def test_jump_backwards_out_of_try_finally_block(output):
         output.append(1)
@@ -1607,8 +1579,6 @@ def test_jump_backwards_out_of_try_finally_block(output):
         finally:
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 6, [6])
     def test_jump_forwards_out_of_try_except_block(output):
         try:
@@ -1618,8 +1588,6 @@ def test_jump_forwards_out_of_try_except_block(output):
             raise
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 1, [1, 1, 3])
     def test_jump_backwards_out_of_try_except_block(output):
         output.append(1)
@@ -1629,8 +1597,6 @@ def test_jump_backwards_out_of_try_except_block(output):
             output.append(5)
             raise
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 7, [4, 7, 8])
     def test_jump_between_except_blocks(output):
         try:
@@ -1642,8 +1608,6 @@ def test_jump_between_except_blocks(output):
             output.append(7)
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 6, [4, 6, 7])
     def test_jump_within_except_block(output):
         try:
@@ -1654,8 +1618,6 @@ def test_jump_within_except_block(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(2, 4, [1, 4, 5, -4])
     def test_jump_across_with(output):
         output.append(1)
@@ -1674,8 +1636,6 @@ async def test_jump_across_async_with(output):
         async with asynctracecontext(output, 4):
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(4, 5, [1, 3, 5, 6])
     def test_jump_out_of_with_block_within_for_block(output):
         output.append(1)
@@ -1696,8 +1656,6 @@ async def test_jump_out_of_async_with_block_within_for_block(output):
             output.append(5)
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(4, 5, [1, 2, 3, 5, -2, 6])
     def test_jump_out_of_with_block_within_with_block(output):
         output.append(1)
@@ -1718,8 +1676,6 @@ async def test_jump_out_of_async_with_block_within_with_block(output):
             output.append(5)
         output.append(6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 6, [2, 4, 6, 7])
     def test_jump_out_of_with_block_within_finally_block(output):
         try:
@@ -1742,8 +1698,6 @@ async def test_jump_out_of_async_with_block_within_finally_block(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(8, 11, [1, 3, 5, 11, 12])
     def test_jump_out_of_complex_nested_blocks(output):
         output.append(1)
@@ -1759,8 +1713,6 @@ def test_jump_out_of_complex_nested_blocks(output):
             output.append(11)
         output.append(12)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 5, [1, 2, 5])
     def test_jump_out_of_with_assignment(output):
         output.append(1)
@@ -1779,8 +1731,6 @@ async def test_jump_out_of_async_with_assignment(output):
             output.append(4)
         output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 6, [1, 6, 8, 9])
     def test_jump_over_return_in_try_finally_block(output):
         output.append(1)
@@ -1793,8 +1743,6 @@ def test_jump_over_return_in_try_finally_block(output):
             output.append(8)
         output.append(9)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 8, [1, 3, 8, 10, 11, 13])
     def test_jump_over_break_in_try_finally_block(output):
         output.append(1)
@@ -1811,8 +1759,6 @@ def test_jump_over_break_in_try_finally_block(output):
             break
         output.append(13)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 7, [7, 8])
     def test_jump_over_for_block_before_else(output):
         output.append(1)
@@ -2015,8 +1961,6 @@ def test_no_jump_between_except_blocks_2(output):
             output.append(7)
         output.append(8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(1, 5, [5])
     def test_jump_into_finally_block(output):
         output.append(1)
@@ -2025,8 +1969,6 @@ def test_jump_into_finally_block(output):
         finally:
             output.append(5)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 6, [2, 6, 7])
     def test_jump_into_finally_block_from_try_block(output):
         try:
@@ -2037,8 +1979,6 @@ def test_jump_into_finally_block_from_try_block(output):
             output.append(6)
         output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(5, 1, [1, 3, 1, 3, 5])
     def test_jump_out_of_finally_block(output):
         output.append(1)
@@ -2117,8 +2057,6 @@ def test_no_jump_out_of_qualified_except_block(output):
             output.append(6)
             output.append(7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @jump_test(3, 5, [1, 2, 5, -2])
     def test_jump_between_with_blocks(output):
         output.append(1)
@@ -2187,8 +2125,6 @@ def test_no_jump_without_trace_function(self):
         # triggered.
         no_jump_without_trace_function()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_large_function(self):
         d = {}
         exec("""def f(output):        # line 0
@@ -2203,8 +2139,6 @@ def test_large_function(self):
         f = d['f']
         self.run_test(f, 2, 1007, [0])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_jump_to_firstlineno(self):
         # This tests that PDB can jump back to the first line in a
         # file.  See issue #1689458.  It can only be triggered in a
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 2bed4cde780..ebd1e670ac0 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -2050,6 +2050,7 @@ impl Compiler {
 
     fn compile_statement(&mut self, statement: &ast::Stmt) -> CompileResult<()> {
         trace!("Compiling {statement:?}");
+        let prev_source_range = self.current_source_range;
         self.set_source_range(statement.range());
 
         match &statement {
@@ -2433,7 +2434,14 @@ impl Compiler {
                 value,
                 simple,
                 ..
-            }) => self.compile_annotated_assign(target, annotation, value.as_deref(), *simple)?,
+            }) => {
+                self.compile_annotated_assign(target, annotation, value.as_deref(), *simple)?;
+                // Bare annotations in function scope emit no code; restore
+                // source range so subsequent instructions keep the correct line.
+                if value.is_none() && self.ctx.in_func() {
+                    self.set_source_range(prev_source_range);
+                }
+            }
             ast::Stmt::Delete(ast::StmtDelete { targets, .. }) => {
                 for target in targets {
                     self.compile_delete(target)?;
@@ -2865,6 +2873,9 @@ impl Compiler {
         // Normal path jumps here to skip exception path blocks
         let end_block = self.new_block();
 
+        // Emit NOP at the try: line so LINE events fire for it
+        emit!(self, Instruction::Nop);
+
         // Setup a finally block if we have a finally statement.
         // Push fblock with handler info for exception table generation
         // IMPORTANT: handler goes to finally_except_block (exception path), not finally_block
@@ -3018,8 +3029,10 @@ impl Compiler {
                 type_,
                 name,
                 body,
+                range: handler_range,
                 ..
             }) = &handler;
+            self.set_source_range(*handler_range);
             let next_handler = self.new_block();
 
             // If we gave a typ,
@@ -3313,6 +3326,9 @@ impl Compiler {
         };
         let exit_block = self.new_block();
 
+        // Emit NOP at the try: line so LINE events fire for it
+        emit!(self, Instruction::Nop);
+
         // Push fblock with handler info for exception table generation
         if !finalbody.is_empty() {
             emit!(
@@ -3743,6 +3759,9 @@ impl Compiler {
         is_async: bool,
         funcflags: bytecode::MakeFunctionFlags,
     ) -> CompileResult<()> {
+        // Save source range so MAKE_FUNCTION gets the `def` line, not the body's last line
+        let saved_range = self.current_source_range;
+
         // Always enter function scope
         self.enter_function(name, parameters)?;
         self.current_code_info()
@@ -3796,6 +3815,8 @@ impl Compiler {
         let code = self.exit_scope();
         self.ctx = prev_ctx;
 
+        self.set_source_range(saved_range);
+
         // Create function object with closure
         self.make_closure(code, funcflags)?;
 
@@ -5166,18 +5187,23 @@ impl Compiler {
         // No PopBlock here - for async, POP_BLOCK is already in for_block
         self.pop_fblock(FBlockType::ForLoop);
 
+        // End-of-loop instructions are on the `for` line, not the body's last line
+        let saved_range = self.current_source_range;
+        self.set_source_range(iter.range());
         if is_async {
             emit!(self, Instruction::EndAsyncFor);
         } else {
-            // END_FOR + POP_ITER pattern (CPython 3.14)
-            // FOR_ITER jumps to END_FOR, but VM skips it (+1) to reach POP_ITER
             emit!(self, Instruction::EndFor);
             emit!(self, Instruction::PopIter);
         }
+        self.set_source_range(saved_range);
         self.compile_statements(orelse)?;
 
         self.switch_to_block(after_block);
 
+        // Implicit return after for-loop should be attributed to the `for` line
+        self.set_source_range(iter.range());
+
         self.leave_conditional_block();
         Ok(())
     }
@@ -6212,6 +6238,8 @@ impl Compiler {
         ops: &[ast::CmpOp],
         comparators: &[ast::Expr],
     ) -> CompileResult<()> {
+        // Save the full Compare expression range for COMPARE_OP positions
+        let compare_range = self.current_source_range;
         let (last_op, mid_ops) = ops.split_last().unwrap();
         let (last_comparator, mid_comparators) = comparators.split_last().unwrap();
 
@@ -6220,6 +6248,7 @@ impl Compiler {
 
         if mid_comparators.is_empty() {
             self.compile_expression(last_comparator)?;
+            self.set_source_range(compare_range);
             self.compile_addcompare(last_op);
 
             return Ok(());
@@ -6232,6 +6261,7 @@ impl Compiler {
             self.compile_expression(comparator)?;
 
             // store rhs for the next comparison in chain
+            self.set_source_range(compare_range);
             emit!(self, Instruction::Swap { index: 2 });
             emit!(self, Instruction::Copy { index: 2 });
 
@@ -6244,6 +6274,7 @@ impl Compiler {
         }
 
         self.compile_expression(last_comparator)?;
+        self.set_source_range(compare_range);
         self.compile_addcompare(last_op);
 
         let end = self.new_block();
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index 651eb59107c..97f4a8c2d8c 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -250,15 +250,32 @@ impl CodeInfo {
         let mut locations = Vec::new();
         let mut linetable_locations: Vec<LineTableLocation> = Vec::new();
 
-        // Convert pseudo ops and remove resulting NOPs
+        // Convert pseudo ops and remove resulting NOPs (keep line-marker NOPs)
         convert_pseudo_ops(&mut blocks, varname_cache.len() as u32);
         for block in blocks
             .iter_mut()
             .filter(|b| b.next != BlockIdx::NULL || !b.instructions.is_empty())
         {
-            block
+            // Collect lines that have non-NOP instructions in this block
+            let non_nop_lines: IndexSet<_> = block
                 .instructions
-                .retain(|ins| !matches!(ins.instr.real(), Some(Instruction::Nop)));
+                .iter()
+                .filter(|ins| !matches!(ins.instr.real(), Some(Instruction::Nop)))
+                .map(|ins| ins.location.line)
+                .collect();
+            let mut kept_nop_lines: IndexSet<OneIndexed> = IndexSet::default();
+            block.instructions.retain(|ins| {
+                if matches!(ins.instr.real(), Some(Instruction::Nop)) {
+                    let line = ins.location.line;
+                    // Remove if another instruction covers this line,
+                    // or if we already kept a NOP for this line
+                    if non_nop_lines.contains(&line) || kept_nop_lines.contains(&line) {
+                        return false;
+                    }
+                    kept_nop_lines.insert(line);
+                }
+                true
+            });
         }
 
         let mut block_to_offset = vec![Label(0); blocks.len()];
@@ -501,9 +518,12 @@ impl CodeInfo {
                 let tuple_const = ConstantData::Tuple { elements };
                 let (const_idx, _) = self.metadata.consts.insert_full(tuple_const);
 
-                // Replace preceding LOAD instructions with NOP
+                // Replace preceding LOAD instructions with NOP at the
+                // BUILD_TUPLE location so remove_nops() can eliminate them.
+                let folded_loc = block.instructions[i].location;
                 for j in start_idx..i {
                     block.instructions[j].instr = Instruction::Nop.into();
+                    block.instructions[j].location = folded_loc;
                 }
 
                 // Replace BUILD_TUPLE with LOAD_CONST
@@ -673,12 +693,21 @@ impl CodeInfo {
         }
     }
 
-    /// Remove NOP instructions from all blocks
+    /// Remove NOP instructions from all blocks, but keep NOPs that introduce
+    /// a new source line (they serve as line markers for monitoring LINE events).
     fn remove_nops(&mut self) {
         for block in &mut self.blocks {
-            block
-                .instructions
-                .retain(|ins| !matches!(ins.instr.real(), Some(Instruction::Nop)));
+            let mut prev_line = None;
+            block.instructions.retain(|ins| {
+                if matches!(ins.instr.real(), Some(Instruction::Nop)) {
+                    let line = ins.location.line;
+                    if prev_line == Some(line) {
+                        return false;
+                    }
+                }
+                prev_line = Some(ins.location.line);
+                true
+            });
         }
     }
 
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
index f80ef5c97fe..0f48c2a90ea 100644
--- a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
@@ -3,8 +3,7 @@ source: crates/codegen/src/compile.rs
 expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n        with self.subTest(type=type(stop_exc)):\n            try:\n                async with egg():\n                    raise stop_exc\n            except Exception as ex:\n                self.assertIs(ex, stop_exc)\n            else:\n                self.fail(f'{stop_exc} was suppressed')\n\")"
 ---
   1           0 RESUME               (0)
-
-  3           1 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RETURN_GENERATOR
+              1 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RETURN_GENERATOR
                   1 POP_TOP
                   2 RESUME               (0)
 
@@ -18,7 +17,7 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                  10 CALL                 (1)
                  11 BUILD_TUPLE          (2)
                  12 GET_ITER
-            >>   13 FOR_ITER             (49)
+            >>   13 FOR_ITER             (50)
                  14 STORE_FAST           (0, stop_exc)
 
   3              15 LOAD_GLOBAL          (2, self)
@@ -37,132 +36,138 @@ expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIter
                  28 CALL                 (0)
                  29 POP_TOP
 
-  5              30 LOAD_GLOBAL          (5, egg)
-                 31 PUSH_NULL
-                 32 CALL                 (0)
-                 33 COPY                 (1)
-                 34 LOAD_SPECIAL         (__aexit__)
-                 35 SWAP                 (2)
-                 36 LOAD_SPECIAL         (__aenter__)
-                 37 PUSH_NULL
-                 38 CALL                 (0)
-                 39 GET_AWAITABLE        (1)
-                 40 LOAD_CONST           (None)
-            >>   41 SEND                 (45)
-                 42 YIELD_VALUE          (1)
-                 43 RESUME               (3)
-                 44 JUMP_BACKWARD_NO_INTERRUPT(41)
-            >>   45 END_SEND
-                 46 POP_TOP
+  4              30 NOP
+
+  5              31 LOAD_GLOBAL          (5, egg)
+                 32 PUSH_NULL
+                 33 CALL                 (0)
+                 34 COPY                 (1)
+                 35 LOAD_SPECIAL         (__aexit__)
+                 36 SWAP                 (2)
+                 37 LOAD_SPECIAL         (__aenter__)
+                 38 PUSH_NULL
+                 39 CALL                 (0)
+                 40 GET_AWAITABLE        (1)
+                 41 LOAD_CONST           (None)
+            >>   42 SEND                 (46)
+                 43 YIELD_VALUE          (1)
+                 44 RESUME               (3)
+                 45 JUMP_BACKWARD_NO_INTERRUPT(42)
+            >>   46 END_SEND
+                 47 POP_TOP
+
+  6              48 LOAD_FAST            (0, stop_exc)
+                 49 RAISE_VARARGS        (Raise)
+
+  2         >>   50 END_FOR
+                 51 POP_ITER
+                 52 LOAD_CONST           (None)
+                 53 RETURN_VALUE
 
-  6              47 LOAD_FAST            (0, stop_exc)
-                 48 RAISE_VARARGS        (Raise)
+  5              54 CLEANUP_THROW
+                 55 JUMP_BACKWARD_NO_INTERRUPT(46)
 
-  3         >>   49 END_FOR
-                 50 POP_ITER
-                 51 LOAD_CONST           (None)
-                 52 RETURN_VALUE
+  6              56 NOP
 
-  5              53 CLEANUP_THROW
-                 54 JUMP_BACKWARD_NO_INTERRUPT(45)
-                 55 PUSH_NULL
-                 56 LOAD_CONST           (None)
-                 57 LOAD_CONST           (None)
+  5              57 PUSH_NULL
                  58 LOAD_CONST           (None)
-                 59 CALL                 (3)
-                 60 GET_AWAITABLE        (2)
-                 61 LOAD_CONST           (None)
-            >>   62 SEND                 (67)
-                 63 YIELD_VALUE          (1)
-                 64 RESUME               (3)
-                 65 JUMP_BACKWARD_NO_INTERRUPT(62)
-                 66 CLEANUP_THROW
-            >>   67 END_SEND
-                 68 POP_TOP
-                 69 JUMP_FORWARD         (92)
-                 70 PUSH_EXC_INFO
-                 71 WITH_EXCEPT_START
-                 72 GET_AWAITABLE        (2)
-                 73 LOAD_CONST           (None)
-            >>   74 SEND                 (79)
-                 75 YIELD_VALUE          (1)
-                 76 RESUME               (3)
-                 77 JUMP_BACKWARD_NO_INTERRUPT(74)
-                 78 CLEANUP_THROW
-            >>   79 END_SEND
-                 80 TO_BOOL
-                 81 POP_JUMP_IF_TRUE     (84)
-                 82 NOT_TAKEN
-                 83 RERAISE              (2)
-            >>   84 POP_TOP
-                 85 POP_EXCEPT
-                 86 POP_TOP
-                 87 POP_TOP
-                 88 JUMP_FORWARD         (92)
-                 89 COPY                 (3)
-                 90 POP_EXCEPT
-                 91 RERAISE              (1)
-            >>   92 JUMP_FORWARD         (119)
-                 93 PUSH_EXC_INFO
+                 59 LOAD_CONST           (None)
+                 60 LOAD_CONST           (None)
+                 61 CALL                 (3)
+                 62 GET_AWAITABLE        (2)
+                 63 LOAD_CONST           (None)
+            >>   64 SEND                 (69)
+                 65 YIELD_VALUE          (1)
+                 66 RESUME               (3)
+                 67 JUMP_BACKWARD_NO_INTERRUPT(64)
+                 68 CLEANUP_THROW
+            >>   69 END_SEND
+                 70 POP_TOP
+                 71 JUMP_FORWARD         (94)
+                 72 PUSH_EXC_INFO
+                 73 WITH_EXCEPT_START
+                 74 GET_AWAITABLE        (2)
+                 75 LOAD_CONST           (None)
+            >>   76 SEND                 (81)
+                 77 YIELD_VALUE          (1)
+                 78 RESUME               (3)
+                 79 JUMP_BACKWARD_NO_INTERRUPT(76)
+                 80 CLEANUP_THROW
+            >>   81 END_SEND
+                 82 TO_BOOL
+                 83 POP_JUMP_IF_TRUE     (86)
+                 84 NOT_TAKEN
+                 85 RERAISE              (2)
+            >>   86 POP_TOP
+                 87 POP_EXCEPT
+                 88 POP_TOP
+                 89 POP_TOP
+                 90 JUMP_FORWARD         (94)
+                 91 COPY                 (3)
+                 92 POP_EXCEPT
+                 93 RERAISE              (1)
+            >>   94 JUMP_FORWARD         (121)
+                 95 PUSH_EXC_INFO
 
-  7              94 LOAD_GLOBAL          (6, Exception)
-                 95 CHECK_EXC_MATCH
-                 96 POP_JUMP_IF_FALSE    (115)
-                 97 NOT_TAKEN
-                 98 STORE_FAST           (1, ex)
+  7              96 LOAD_GLOBAL          (6, Exception)
+                 97 CHECK_EXC_MATCH
+                 98 POP_JUMP_IF_FALSE    (117)
+                 99 NOT_TAKEN
+                100 STORE_FAST           (1, ex)
 
-  8              99 LOAD_GLOBAL          (2, self)
-                100 LOAD_ATTR            (15, assertIs, method=true)
-                101 LOAD_FAST            (1, ex)
-                102 LOAD_FAST            (0, stop_exc)
-                103 CALL                 (2)
-                104 POP_TOP
-                105 JUMP_BACKWARD_NO_INTERRUPT(110)
-                106 LOAD_CONST           (None)
-                107 STORE_FAST           (1, ex)
-                108 DELETE_FAST          (1, ex)
-                109 RAISE_VARARGS        (ReraiseFromStack)
-            >>  110 POP_EXCEPT
-                111 LOAD_CONST           (None)
-                112 STORE_FAST           (1, ex)
-                113 DELETE_FAST          (1, ex)
-                114 JUMP_BACKWARD_NO_INTERRUPT(127)
-            >>  115 RAISE_VARARGS        (ReraiseFromStack)
-                116 COPY                 (3)
-                117 POP_EXCEPT
-                118 RAISE_VARARGS        (ReraiseFromStack)
+  8             101 LOAD_GLOBAL          (2, self)
+                102 LOAD_ATTR            (15, assertIs, method=true)
+                103 LOAD_FAST            (1, ex)
+                104 LOAD_FAST            (0, stop_exc)
+                105 CALL                 (2)
+                106 POP_TOP
+                107 JUMP_BACKWARD_NO_INTERRUPT(112)
+                108 LOAD_CONST           (None)
+                109 STORE_FAST           (1, ex)
+                110 DELETE_FAST          (1, ex)
+                111 RAISE_VARARGS        (ReraiseFromStack)
+            >>  112 POP_EXCEPT
+                113 LOAD_CONST           (None)
+                114 STORE_FAST           (1, ex)
+                115 DELETE_FAST          (1, ex)
+                116 JUMP_BACKWARD_NO_INTERRUPT(129)
+            >>  117 RAISE_VARARGS        (ReraiseFromStack)
+                118 COPY                 (3)
+                119 POP_EXCEPT
+                120 RAISE_VARARGS        (ReraiseFromStack)
 
- 10         >>  119 LOAD_GLOBAL          (2, self)
-                120 LOAD_ATTR            (17, fail, method=true)
-                121 LOAD_FAST_BORROW     (0, stop_exc)
-                122 FORMAT_SIMPLE
-                123 LOAD_CONST           (" was suppressed")
-                124 BUILD_STRING         (2)
-                125 CALL                 (1)
-                126 POP_TOP
+ 10         >>  121 LOAD_GLOBAL          (2, self)
+                122 LOAD_ATTR            (17, fail, method=true)
+                123 LOAD_FAST_BORROW     (0, stop_exc)
+                124 FORMAT_SIMPLE
+                125 LOAD_CONST           (" was suppressed")
+                126 BUILD_STRING         (2)
+                127 CALL                 (1)
+                128 POP_TOP
+            >>  129 NOP
 
-  3         >>  127 PUSH_NULL
-                128 LOAD_CONST           (None)
-                129 LOAD_CONST           (None)
-                130 LOAD_CONST           (None)
-                131 CALL                 (3)
-                132 POP_TOP
-                133 JUMP_FORWARD         (148)
-                134 PUSH_EXC_INFO
-                135 WITH_EXCEPT_START
-                136 TO_BOOL
-                137 POP_JUMP_IF_TRUE     (140)
-                138 NOT_TAKEN
-                139 RERAISE              (2)
-            >>  140 POP_TOP
-                141 POP_EXCEPT
-                142 POP_TOP
-                143 POP_TOP
-                144 JUMP_FORWARD         (148)
-                145 COPY                 (3)
-                146 POP_EXCEPT
-                147 RERAISE              (1)
-            >>  148 JUMP_BACKWARD        (13)
+  3             130 PUSH_NULL
+                131 LOAD_CONST           (None)
+                132 LOAD_CONST           (None)
+                133 LOAD_CONST           (None)
+                134 CALL                 (3)
+                135 POP_TOP
+                136 JUMP_FORWARD         (151)
+                137 PUSH_EXC_INFO
+                138 WITH_EXCEPT_START
+                139 TO_BOOL
+                140 POP_JUMP_IF_TRUE     (143)
+                141 NOT_TAKEN
+                142 RERAISE              (2)
+            >>  143 POP_TOP
+                144 POP_EXCEPT
+                145 POP_TOP
+                146 POP_TOP
+                147 JUMP_FORWARD         (151)
+                148 COPY                 (3)
+                149 POP_EXCEPT
+                150 RERAISE              (1)
+            >>  151 JUMP_BACKWARD        (13)
 
               2 MAKE_FUNCTION
               3 STORE_NAME           (0, test)
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index a6d19795076..cece1fb77fa 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 use alloc::{borrow::ToOwned, boxed::Box, collections::BTreeSet, fmt, string::String, vec::Vec};
 use bitflags::bitflags;
-use core::{hash, mem, ops::Deref};
+use core::{cell::UnsafeCell, hash, mem, ops::Deref};
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex64;
@@ -99,6 +99,37 @@ pub fn find_exception_handler(table: &[u8], offset: u32) -> Option<ExceptionTabl
     None
 }
 
+/// Decode all exception table entries.
+pub fn decode_exception_table(table: &[u8]) -> Vec<ExceptionTableEntry> {
+    let mut entries = Vec::new();
+    let mut pos = 0;
+    while pos < table.len() {
+        let Some(start) = read_varint_with_start(table, &mut pos) else {
+            break;
+        };
+        let Some(size) = read_varint(table, &mut pos) else {
+            break;
+        };
+        let Some(target) = read_varint(table, &mut pos) else {
+            break;
+        };
+        let Some(depth_lasti) = read_varint(table, &mut pos) else {
+            break;
+        };
+        let Some(end) = start.checked_add(size) else {
+            break;
+        };
+        entries.push(ExceptionTableEntry {
+            start,
+            end,
+            target,
+            depth: (depth_lasti >> 1) as u16,
+            push_lasti: (depth_lasti & 1) != 0,
+        });
+    }
+    entries
+}
+
 /// CPython 3.11+ linetable location info codes
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u8)]
@@ -329,8 +360,28 @@ impl TryFrom<&[u8]> for CodeUnit {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct CodeUnits(Box<[CodeUnit]>);
+pub struct CodeUnits(UnsafeCell<Box<[CodeUnit]>>);
+
+// SAFETY: All mutation of the inner buffer is serialized by `monitoring_data: PyMutex`
+// in `PyCode`. The `UnsafeCell` is required because `replace_op` mutates through `&self`.
+unsafe impl Sync for CodeUnits {}
+
+impl Clone for CodeUnits {
+    fn clone(&self) -> Self {
+        // SAFETY: No concurrent mutation during clone — cloning is only done
+        // during code object construction or marshaling, not while instrumented.
+        let inner = unsafe { &*self.0.get() };
+        Self(UnsafeCell::new(inner.clone()))
+    }
+}
+
+impl fmt::Debug for CodeUnits {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // SAFETY: Debug formatting doesn't race with replace_op
+        let inner = unsafe { &*self.0.get() };
+        f.debug_tuple("CodeUnits").field(inner).finish()
+    }
+}
 
 impl TryFrom<&[u8]> for CodeUnits {
     type Error = MarshalError;
@@ -346,19 +397,19 @@ impl TryFrom<&[u8]> for CodeUnits {
 
 impl<const N: usize> From<[CodeUnit; N]> for CodeUnits {
     fn from(value: [CodeUnit; N]) -> Self {
-        Self(Box::from(value))
+        Self(UnsafeCell::new(Box::from(value)))
     }
 }
 
 impl From<Vec<CodeUnit>> for CodeUnits {
     fn from(value: Vec<CodeUnit>) -> Self {
-        Self(value.into_boxed_slice())
+        Self(UnsafeCell::new(value.into_boxed_slice()))
     }
 }
 
 impl FromIterator<CodeUnit> for CodeUnits {
     fn from_iter<T: IntoIterator<Item = CodeUnit>>(iter: T) -> Self {
-        Self(iter.into_iter().collect())
+        Self(UnsafeCell::new(iter.into_iter().collect()))
     }
 }
 
@@ -366,7 +417,29 @@ impl Deref for CodeUnits {
     type Target = [CodeUnit];
 
     fn deref(&self) -> &Self::Target {
-        &self.0
+        // SAFETY: Shared references to the slice are valid even while replace_op
+        // may update individual opcode bytes — readers tolerate stale opcodes
+        // (they will re-read on the next iteration).
+        unsafe { &*self.0.get() }
+    }
+}
+
+impl CodeUnits {
+    /// Replace the opcode at `index` in-place without changing the arg byte.
+    ///
+    /// # Safety
+    /// - `index` must be in bounds.
+    /// - `new_op` must have the same arg semantics as the original opcode.
+    /// - The caller must ensure exclusive access to the instruction buffer
+    ///   (no concurrent reads or writes to the same `CodeUnits`).
+    pub unsafe fn replace_op(&self, index: usize, new_op: Instruction) {
+        unsafe {
+            let units = &mut *self.0.get();
+            let unit_ptr = units.as_mut_ptr().add(index);
+            // Write only the opcode byte (first byte of CodeUnit due to #[repr(C)])
+            let op_ptr = unit_ptr as *mut u8;
+            core::ptr::write(op_ptr, new_op.into());
+        }
     }
 }
 
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index 6f43e79c168..8ba71381dbc 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -419,6 +419,100 @@ impl TryFrom<u8> for Instruction {
     }
 }
 
+impl Instruction {
+    /// Returns `true` if this is any instrumented opcode
+    /// (regular INSTRUMENTED_*, INSTRUMENTED_LINE, or INSTRUMENTED_INSTRUCTION).
+    pub fn is_instrumented(self) -> bool {
+        self.to_base().is_some()
+            || matches!(self, Self::InstrumentedLine | Self::InstrumentedInstruction)
+    }
+
+    /// Map a base opcode to its INSTRUMENTED_* variant.
+    /// Returns `None` if this opcode has no instrumented counterpart.
+    ///
+    /// # Panics (debug)
+    /// Panics if called on an already-instrumented opcode.
+    pub fn to_instrumented(self) -> Option<Self> {
+        debug_assert!(
+            !self.is_instrumented(),
+            "to_instrumented called on already-instrumented opcode {self:?}"
+        );
+        Some(match self {
+            Self::Resume { .. } => Self::InstrumentedResume,
+            Self::ReturnValue => Self::InstrumentedReturnValue,
+            Self::YieldValue { .. } => Self::InstrumentedYieldValue,
+            Self::Call { .. } => Self::InstrumentedCall,
+            Self::CallKw { .. } => Self::InstrumentedCallKw,
+            Self::CallFunctionEx => Self::InstrumentedCallFunctionEx,
+            Self::LoadSuperAttr { .. } => Self::InstrumentedLoadSuperAttr,
+            Self::JumpForward { .. } => Self::InstrumentedJumpForward,
+            Self::JumpBackward { .. } => Self::InstrumentedJumpBackward,
+            Self::ForIter { .. } => Self::InstrumentedForIter,
+            Self::EndFor => Self::InstrumentedEndFor,
+            Self::EndSend => Self::InstrumentedEndSend,
+            Self::PopJumpIfTrue { .. } => Self::InstrumentedPopJumpIfTrue,
+            Self::PopJumpIfFalse { .. } => Self::InstrumentedPopJumpIfFalse,
+            Self::PopJumpIfNone { .. } => Self::InstrumentedPopJumpIfNone,
+            Self::PopJumpIfNotNone { .. } => Self::InstrumentedPopJumpIfNotNone,
+            Self::NotTaken => Self::InstrumentedNotTaken,
+            Self::PopIter => Self::InstrumentedPopIter,
+            Self::EndAsyncFor => Self::InstrumentedEndAsyncFor,
+            _ => return None,
+        })
+    }
+
+    /// Map an INSTRUMENTED_* opcode back to its base variant.
+    /// Returns `None` for non-instrumented opcodes, and also for
+    /// `InstrumentedLine` / `InstrumentedInstruction` which are event-layer
+    /// placeholders without a fixed base opcode (the real opcode is stored in
+    /// `CoMonitoringData`).
+    ///
+    /// The returned base opcode uses `Arg::marker()` for typed fields —
+    /// only the opcode byte matters since `replace_op` preserves the arg byte.
+    pub fn to_base(self) -> Option<Self> {
+        Some(match self {
+            Self::InstrumentedResume => Self::Resume { arg: Arg::marker() },
+            Self::InstrumentedReturnValue => Self::ReturnValue,
+            Self::InstrumentedYieldValue => Self::YieldValue { arg: Arg::marker() },
+            Self::InstrumentedCall => Self::Call {
+                nargs: Arg::marker(),
+            },
+            Self::InstrumentedCallKw => Self::CallKw {
+                nargs: Arg::marker(),
+            },
+            Self::InstrumentedCallFunctionEx => Self::CallFunctionEx,
+            Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr { arg: Arg::marker() },
+            Self::InstrumentedJumpForward => Self::JumpForward {
+                target: Arg::marker(),
+            },
+            Self::InstrumentedJumpBackward => Self::JumpBackward {
+                target: Arg::marker(),
+            },
+            Self::InstrumentedForIter => Self::ForIter {
+                target: Arg::marker(),
+            },
+            Self::InstrumentedEndFor => Self::EndFor,
+            Self::InstrumentedEndSend => Self::EndSend,
+            Self::InstrumentedPopJumpIfTrue => Self::PopJumpIfTrue {
+                target: Arg::marker(),
+            },
+            Self::InstrumentedPopJumpIfFalse => Self::PopJumpIfFalse {
+                target: Arg::marker(),
+            },
+            Self::InstrumentedPopJumpIfNone => Self::PopJumpIfNone {
+                target: Arg::marker(),
+            },
+            Self::InstrumentedPopJumpIfNotNone => Self::PopJumpIfNotNone {
+                target: Arg::marker(),
+            },
+            Self::InstrumentedNotTaken => Self::NotTaken,
+            Self::InstrumentedPopIter => Self::PopIter,
+            Self::InstrumentedEndAsyncFor => Self::EndAsyncFor,
+            _ => return None,
+        })
+    }
+}
+
 impl InstructionMetadata for Instruction {
     #[inline]
     fn label_arg(&self) -> Option<Arg<Label>> {
diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
index fcaff687946..18d40a818f2 100644
--- a/crates/vm/src/builtins/code.rs
+++ b/crates/vm/src/builtins/code.rs
@@ -1,10 +1,11 @@
 //! Infamous code object. The python class `code`
 
 use super::{PyBytesRef, PyStrRef, PyTupleRef, PyType};
+use crate::common::lock::PyMutex;
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     builtins::PyStrInterned,
-    bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag},
+    bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag, Instruction},
     class::{PyClassImpl, StaticType},
     convert::{ToPyException, ToPyObject},
     frozen,
@@ -15,7 +16,7 @@ use alloc::fmt;
 use core::{
     borrow::Borrow,
     ops::Deref,
-    sync::atomic::{AtomicPtr, Ordering},
+    sync::atomic::{AtomicPtr, AtomicU64, Ordering},
 };
 use malachite_bigint::BigInt;
 use num_traits::Zero;
@@ -324,10 +325,27 @@ impl<B: AsRef<[u8]>> IntoCodeObject for frozen::FrozenCodeObject<B> {
     }
 }
 
+/// Per-code-object monitoring data (_PyCoMonitoringData).
+/// Stores original opcodes displaced by INSTRUMENTED_LINE / INSTRUMENTED_INSTRUCTION.
+pub struct CoMonitoringData {
+    /// Original opcodes at positions with INSTRUMENTED_LINE.
+    /// Indexed by instruction index. 0 = not instrumented for LINE.
+    pub line_opcodes: Vec<u8>,
+
+    /// Original opcodes at positions with INSTRUMENTED_INSTRUCTION.
+    /// Indexed by instruction index. 0 = not instrumented for INSTRUCTION.
+    pub per_instruction_opcodes: Vec<u8>,
+}
+
 #[pyclass(module = false, name = "code")]
 pub struct PyCode {
     pub code: CodeObject,
     source_path: AtomicPtr<PyStrInterned>,
+    /// Version counter for lazy re-instrumentation.
+    /// Compared against `PyGlobalState::instrumentation_version` at RESUME.
+    pub instrumentation_version: AtomicU64,
+    /// Side-table for INSTRUMENTED_LINE / INSTRUMENTED_INSTRUCTION.
+    pub monitoring_data: PyMutex<Option<CoMonitoringData>>,
 }
 
 impl Deref for PyCode {
@@ -343,6 +361,8 @@ impl PyCode {
         Self {
             code,
             source_path: AtomicPtr::new(sp),
+            instrumentation_version: AtomicU64::new(0),
+            monitoring_data: PyMutex::new(None),
         }
     }
 
@@ -893,6 +913,79 @@ impl PyCode {
         vm.call_method(list.as_object(), "__iter__", ())
     }
 
+    #[pymethod]
+    pub fn co_branches(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let instructions = &self.code.instructions;
+        let mut branches = Vec::new();
+        let mut extended_arg: u32 = 0;
+
+        for (i, unit) in instructions.iter().enumerate() {
+            // De-instrument: use base opcode for instrumented variants
+            let op = unit.op.to_base().unwrap_or(unit.op);
+            let raw_arg = u32::from(u8::from(unit.arg));
+
+            if matches!(op, Instruction::ExtendedArg) {
+                extended_arg = (extended_arg | raw_arg) << 8;
+                continue;
+            }
+
+            let oparg = extended_arg | raw_arg;
+            extended_arg = 0;
+
+            let (src, left, right) = match op {
+                Instruction::ForIter { .. } => {
+                    // left = fall-through (continue iteration)
+                    // right = past END_FOR (iterator exhausted, skip cleanup)
+                    let target = oparg as usize;
+                    let right = if matches!(
+                        instructions.get(target).map(|u| u.op),
+                        Some(Instruction::EndFor) | Some(Instruction::InstrumentedEndFor)
+                    ) {
+                        (target + 1) * 2
+                    } else {
+                        target * 2
+                    };
+                    (i * 2, (i + 1) * 2, right)
+                }
+                Instruction::PopJumpIfFalse { .. }
+                | Instruction::PopJumpIfTrue { .. }
+                | Instruction::PopJumpIfNone { .. }
+                | Instruction::PopJumpIfNotNone { .. } => {
+                    // left = fall-through (skip NOT_TAKEN if present)
+                    // right = jump target (condition met)
+                    let next_op = instructions
+                        .get(i + 1)
+                        .map(|u| u.op.to_base().unwrap_or(u.op));
+                    let fallthrough = if matches!(next_op, Some(Instruction::NotTaken)) {
+                        (i + 2) * 2
+                    } else {
+                        (i + 1) * 2
+                    };
+                    (i * 2, fallthrough, oparg as usize * 2)
+                }
+                Instruction::EndAsyncFor => {
+                    // src = END_SEND position (next_i - oparg)
+                    let next_i = i + 1;
+                    let Some(src_i) = next_i.checked_sub(oparg as usize) else {
+                        continue;
+                    };
+                    (src_i * 2, (src_i + 2) * 2, next_i * 2)
+                }
+                _ => continue,
+            };
+
+            let tuple = vm.ctx.new_tuple(vec![
+                vm.ctx.new_int(src).into(),
+                vm.ctx.new_int(left).into(),
+                vm.ctx.new_int(right).into(),
+            ]);
+            branches.push(tuple.into());
+        }
+
+        let list = vm.ctx.new_list(branches);
+        vm.call_method(list.as_object(), "__iter__", ())
+    }
+
     #[pymethod]
     pub fn replace(&self, args: ReplaceArgs, vm: &VirtualMachine) -> PyResult<Self> {
         let ReplaceArgs {
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
index 6ee8620b7d2..67c49962a91 100644
--- a/crates/vm/src/builtins/frame.rs
+++ b/crates/vm/src/builtins/frame.rs
@@ -11,6 +11,417 @@ use crate::{
     types::Representable,
 };
 use num_traits::Zero;
+use rustpython_compiler_core::bytecode::{
+    self, Constant, Instruction, InstructionMetadata, StackEffect,
+};
+use stack_analysis::*;
+
+/// Stack state analysis for safe line-number jumps.
+///
+/// Models the evaluation stack as a 64-bit integer, encoding the kind of each
+/// stack entry in 3-bit blocks. Used by `set_f_lineno` to verify that a jump
+/// is safe and to determine how many values need to be popped.
+pub(crate) mod stack_analysis {
+    use super::*;
+
+    const BITS_PER_BLOCK: u32 = 3;
+    const MASK: i64 = (1 << BITS_PER_BLOCK) - 1; // 0b111
+    const MAX_STACK_ENTRIES: u32 = 63 / BITS_PER_BLOCK; // 21
+    const WILL_OVERFLOW: u64 = 1u64 << ((MAX_STACK_ENTRIES - 1) * BITS_PER_BLOCK);
+
+    pub const EMPTY_STACK: i64 = 0;
+    pub const UNINITIALIZED: i64 = -2;
+    pub const OVERFLOWED: i64 = -1;
+
+    /// Kind of a stack entry.
+    #[derive(Clone, Copy, PartialEq, Eq, Debug)]
+    #[repr(i64)]
+    pub enum Kind {
+        Iterator = 1,
+        Except = 2,
+        Object = 3,
+        Null = 4,
+        Lasti = 5,
+    }
+
+    impl Kind {
+        fn from_i64(v: i64) -> Option<Self> {
+            match v {
+                1 => Some(Kind::Iterator),
+                2 => Some(Kind::Except),
+                3 => Some(Kind::Object),
+                4 => Some(Kind::Null),
+                5 => Some(Kind::Lasti),
+                _ => None,
+            }
+        }
+    }
+
+    pub fn push_value(stack: i64, kind: i64) -> i64 {
+        if (stack as u64) >= WILL_OVERFLOW {
+            OVERFLOWED
+        } else {
+            (stack << BITS_PER_BLOCK) | kind
+        }
+    }
+
+    pub fn pop_value(stack: i64) -> i64 {
+        stack >> BITS_PER_BLOCK
+    }
+
+    pub fn top_of_stack(stack: i64) -> i64 {
+        stack & MASK
+    }
+
+    fn peek(stack: i64, n: u32) -> i64 {
+        debug_assert!(n >= 1);
+        (stack >> (BITS_PER_BLOCK * (n - 1))) & MASK
+    }
+
+    fn stack_swap(stack: i64, n: u32) -> i64 {
+        debug_assert!(n >= 1);
+        let to_swap = peek(stack, n);
+        let top = top_of_stack(stack);
+        let shift = BITS_PER_BLOCK * (n - 1);
+        let replaced_low = (stack & !(MASK << shift)) | (top << shift);
+        (replaced_low & !MASK) | to_swap
+    }
+
+    fn pop_to_level(mut stack: i64, level: u32) -> i64 {
+        if level == 0 {
+            return EMPTY_STACK;
+        }
+        let max_item: i64 = (1 << BITS_PER_BLOCK) - 1;
+        let level_max_stack = max_item << ((level - 1) * BITS_PER_BLOCK);
+        while stack > level_max_stack {
+            stack = pop_value(stack);
+        }
+        stack
+    }
+
+    fn compatible_kind(from: i64, to: i64) -> bool {
+        if to == 0 {
+            return false;
+        }
+        if to == Kind::Object as i64 {
+            return from != Kind::Null as i64;
+        }
+        if to == Kind::Null as i64 {
+            return true;
+        }
+        from == to
+    }
+
+    pub fn compatible_stack(from_stack: i64, to_stack: i64) -> bool {
+        if from_stack < 0 || to_stack < 0 {
+            return false;
+        }
+        let mut from = from_stack;
+        let mut to = to_stack;
+        while from > to {
+            from = pop_value(from);
+        }
+        while from != 0 {
+            let from_top = top_of_stack(from);
+            let to_top = top_of_stack(to);
+            if !compatible_kind(from_top, to_top) {
+                return false;
+            }
+            from = pop_value(from);
+            to = pop_value(to);
+        }
+        to == 0
+    }
+
+    pub fn explain_incompatible_stack(to_stack: i64) -> &'static str {
+        debug_assert!(to_stack != 0);
+        if to_stack == OVERFLOWED {
+            return "stack is too deep to analyze";
+        }
+        if to_stack == UNINITIALIZED {
+            return "can't jump into an exception handler, or code may be unreachable";
+        }
+        match Kind::from_i64(top_of_stack(to_stack)) {
+            Some(Kind::Except) => "can't jump into an 'except' block as there's no exception",
+            Some(Kind::Lasti) => "can't jump into a re-raising block as there's no location",
+            Some(Kind::Iterator) => "can't jump into the body of a for loop",
+            _ => "incompatible stacks",
+        }
+    }
+
+    /// Analyze bytecode and compute the stack state at each instruction index.
+    pub fn mark_stacks<C: Constant>(code: &bytecode::CodeObject<C>) -> Vec<i64> {
+        let instructions = &*code.instructions;
+        let len = instructions.len();
+
+        let mut stacks = vec![UNINITIALIZED; len + 1];
+        stacks[0] = EMPTY_STACK;
+
+        let mut todo = true;
+        while todo {
+            todo = false;
+
+            let mut i = 0;
+            while i < len {
+                let mut next_stack = stacks[i];
+                let mut opcode = instructions[i].op;
+                let mut oparg: u32 = 0;
+
+                // Accumulate EXTENDED_ARG prefixes
+                while matches!(opcode, Instruction::ExtendedArg) {
+                    oparg = (oparg << 8) | u32::from(u8::from(instructions[i].arg));
+                    i += 1;
+                    if i >= len {
+                        break;
+                    }
+                    stacks[i] = next_stack;
+                    opcode = instructions[i].op;
+                }
+                if i >= len {
+                    break;
+                }
+                oparg = (oparg << 8) | u32::from(u8::from(instructions[i].arg));
+
+                // De-instrument: get the underlying real instruction
+                let opcode = opcode.to_base().unwrap_or(opcode);
+
+                let next_i = i + 1; // No inline caches in RustPython
+
+                if next_stack == UNINITIALIZED {
+                    i = next_i;
+                    continue;
+                }
+
+                match opcode {
+                    Instruction::PopJumpIfFalse { .. }
+                    | Instruction::PopJumpIfTrue { .. }
+                    | Instruction::PopJumpIfNone { .. }
+                    | Instruction::PopJumpIfNotNone { .. } => {
+                        // Jump target is absolute instruction index
+                        let j = oparg as usize;
+                        next_stack = pop_value(next_stack);
+                        let target_stack = next_stack;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = target_stack;
+                        }
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::Send { .. } => {
+                        // target is absolute
+                        let j = oparg as usize;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                        }
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::JumpForward { .. } => {
+                        // target is absolute in RustPython
+                        let j = oparg as usize;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                        }
+                    }
+                    Instruction::JumpBackward { .. }
+                    | Instruction::JumpBackwardNoInterrupt { .. } => {
+                        // target is absolute in RustPython
+                        let j = oparg as usize;
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                            if j < i {
+                                todo = true;
+                            }
+                        }
+                    }
+                    Instruction::GetIter | Instruction::GetAIter => {
+                        next_stack = push_value(pop_value(next_stack), Kind::Iterator as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::ForIter { .. } => {
+                        // Fall-through (iteration continues): pushes the next value
+                        let body_stack = push_value(next_stack, Kind::Object as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = body_stack;
+                        }
+                        // Exhaustion path: execute_for_iter skips END_FOR and
+                        // jumps directly to POP_ITER. The iterator stays on
+                        // the stack and POP_ITER removes it.
+                        let mut j = oparg as usize;
+                        if j < instructions.len() {
+                            let target_op =
+                                instructions[j].op.to_base().unwrap_or(instructions[j].op);
+                            if matches!(target_op, Instruction::EndFor) {
+                                j += 1;
+                            }
+                        }
+                        if j < stacks.len() && stacks[j] == UNINITIALIZED {
+                            stacks[j] = next_stack;
+                        }
+                    }
+                    Instruction::EndAsyncFor => {
+                        next_stack = pop_value(pop_value(next_stack));
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::PushExcInfo => {
+                        next_stack = push_value(next_stack, Kind::Except as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::PopExcept => {
+                        next_stack = pop_value(next_stack);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::ReturnValue => {
+                        // End of block, no fall-through
+                    }
+                    Instruction::RaiseVarargs { .. } => {
+                        // End of block, no fall-through
+                    }
+                    Instruction::Reraise { .. } => {
+                        // End of block, no fall-through
+                    }
+                    Instruction::PushNull => {
+                        next_stack = push_value(next_stack, Kind::Null as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::LoadGlobal(_) => {
+                        // RustPython's LOAD_GLOBAL doesn't encode push_null in oparg
+                        // (separate PUSH_NULL instructions are used instead)
+                        next_stack = push_value(next_stack, Kind::Object as i64);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::LoadAttr { .. } => {
+                        // LoadAttr: pops object, pushes result
+                        // If oparg & 1, it also pushes Null (method load)
+                        let attr_oparg = oparg;
+                        if attr_oparg & 1 != 0 {
+                            next_stack = pop_value(next_stack);
+                            next_stack = push_value(next_stack, Kind::Object as i64);
+                            next_stack = push_value(next_stack, Kind::Null as i64);
+                        }
+                        // else: default stack_effect handles it
+                        else {
+                            let effect: StackEffect = opcode.stack_effect_info(oparg);
+                            let popped = effect.popped() as i64;
+                            let pushed = effect.pushed() as i64;
+                            for _ in 0..popped {
+                                next_stack = pop_value(next_stack);
+                            }
+                            for _ in 0..pushed {
+                                next_stack = push_value(next_stack, Kind::Object as i64);
+                            }
+                        }
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::Swap { .. } => {
+                        let n = oparg;
+                        next_stack = stack_swap(next_stack, n);
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    Instruction::Copy { .. } => {
+                        let n = oparg;
+                        next_stack = push_value(next_stack, peek(next_stack, n));
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                    _ => {
+                        // Default: use stack_effect
+                        let effect: StackEffect = opcode.stack_effect_info(oparg);
+                        let popped = effect.popped() as i64;
+                        let pushed = effect.pushed() as i64;
+                        let mut ns = next_stack;
+                        for _ in 0..popped {
+                            ns = pop_value(ns);
+                        }
+                        for _ in 0..pushed {
+                            ns = push_value(ns, Kind::Object as i64);
+                        }
+                        next_stack = ns;
+                        if next_i < stacks.len() {
+                            stacks[next_i] = next_stack;
+                        }
+                    }
+                }
+                i = next_i;
+            }
+
+            // Scan exception table
+            let exception_table = bytecode::decode_exception_table(&code.exceptiontable);
+            for entry in &exception_table {
+                let start_offset = entry.start as usize;
+                let handler = entry.target as usize;
+                let level = entry.depth as u32;
+                let has_lasti = entry.push_lasti;
+
+                if start_offset < stacks.len()
+                    && stacks[start_offset] != UNINITIALIZED
+                    && handler < stacks.len()
+                    && stacks[handler] == UNINITIALIZED
+                {
+                    todo = true;
+                    let mut target_stack = pop_to_level(stacks[start_offset], level);
+                    if has_lasti {
+                        target_stack = push_value(target_stack, Kind::Lasti as i64);
+                    }
+                    target_stack = push_value(target_stack, Kind::Except as i64);
+                    stacks[handler] = target_stack;
+                }
+            }
+        }
+
+        stacks
+    }
+
+    /// Build a mapping from instruction index to line number.
+    /// Returns -1 for indices with no line start.
+    pub fn mark_lines<C: Constant>(code: &bytecode::CodeObject<C>) -> Vec<i32> {
+        let len = code.instructions.len();
+        let mut line_starts = vec![-1i32; len];
+        let mut last_line: i32 = -1;
+
+        for (i, (loc, _)) in code.locations.iter().enumerate() {
+            if i >= len {
+                break;
+            }
+            let line = loc.line.get() as i32;
+            if line != last_line && line > 0 {
+                line_starts[i] = line;
+                last_line = line;
+            }
+        }
+        line_starts
+    }
+
+    /// Find the first line number >= `line` that has code.
+    pub fn first_line_not_before(lines: &[i32], line: i32) -> i32 {
+        let mut result = i32::MAX;
+        for &l in lines {
+            if l >= line && l < result {
+                result = l;
+            }
+        }
+        if result == i32::MAX { -1 } else { result }
+    }
+}
 
 pub fn init(context: &Context) {
     Frame::extend_class(context, context.types.frame_type);
@@ -71,6 +482,113 @@ impl Frame {
         }
     }
 
+    #[pygetset(setter)]
+    fn set_f_lineno(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        let l_new_lineno = match value {
+            PySetterValue::Assign(val) => {
+                let line_ref: PyIntRef = val
+                    .downcast()
+                    .map_err(|_| vm.new_value_error("lineno must be an integer".to_owned()))?;
+                line_ref
+                    .try_to_primitive::<i32>(vm)
+                    .map_err(|_| vm.new_value_error("lineno must be an integer".to_owned()))?
+            }
+            PySetterValue::Delete => {
+                return Err(vm.new_type_error("can't delete f_lineno attribute".to_owned()));
+            }
+        };
+
+        let first_line = self
+            .code
+            .first_line_number
+            .map(|n| n.get() as i32)
+            .unwrap_or(1);
+
+        if l_new_lineno < first_line {
+            return Err(vm.new_value_error(format!(
+                "line {l_new_lineno} comes before the current code block"
+            )));
+        }
+
+        let py_code: &PyCode = &self.code;
+        let code = &py_code.code;
+        let lines = mark_lines(code);
+
+        // Find the first line >= target that has actual code
+        let new_lineno = first_line_not_before(&lines, l_new_lineno);
+        if new_lineno < 0 {
+            return Err(vm.new_value_error(format!(
+                "line {l_new_lineno} comes after the current code block"
+            )));
+        }
+
+        let stacks = mark_stacks(code);
+        let len = self.code.instructions.len();
+
+        // lasti points past the current instruction (already incremented).
+        // stacks[lasti - 1] gives the stack state before executing the
+        // instruction that triggered this trace event, which is the current
+        // evaluation stack.
+        let current_lasti = self.lasti() as usize;
+        let start_idx = current_lasti.saturating_sub(1);
+        let start_stack = if start_idx < stacks.len() {
+            stacks[start_idx]
+        } else {
+            OVERFLOWED
+        };
+        let mut best_stack = OVERFLOWED;
+        let mut best_addr: i32 = -1;
+        let mut err: i32 = -1;
+        let mut msg = "cannot find bytecode for specified line";
+
+        for i in 0..len {
+            if lines[i] == new_lineno {
+                let target_stack = stacks[i];
+                if compatible_stack(start_stack, target_stack) {
+                    err = 0;
+                    if target_stack > best_stack {
+                        best_stack = target_stack;
+                        best_addr = i as i32;
+                    }
+                } else if err < 0 {
+                    if start_stack == OVERFLOWED {
+                        msg = "stack to deep to analyze";
+                    } else if start_stack == UNINITIALIZED {
+                        msg = "can't jump from unreachable code";
+                    } else {
+                        msg = explain_incompatible_stack(target_stack);
+                        err = 1;
+                    }
+                }
+            }
+        }
+
+        if err != 0 {
+            return Err(vm.new_value_error(msg.to_owned()));
+        }
+
+        // Count how many entries to pop
+        let mut pop_count = 0usize;
+        {
+            let mut s = start_stack;
+            while s > best_stack {
+                pop_count += 1;
+                s = pop_value(s);
+            }
+        }
+
+        // Store the pending unwind for the execution loop to perform.
+        // We cannot pop stack entries here because the execution loop
+        // holds the state mutex, and trying to lock it again would deadlock.
+        self.set_pending_stack_pops(pop_count as u32);
+        self.set_pending_unwind_from_stack(start_stack);
+
+        // Set lasti to best_addr. The executor will read lasti and execute
+        // the instruction at that index next.
+        self.set_lasti(best_addr as u32);
+        Ok(())
+    }
+
     #[pygetset]
     fn f_trace(&self) -> PyObjectRef {
         let boxed = self.trace.lock();
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index 313266eef9d..5224a54ed54 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -7,6 +7,7 @@ use crate::{
         PyInterpolation, PyList, PySet, PySlice, PyStr, PyStrInterned, PyTemplate, PyTraceback,
         PyType, PyUtf8Str,
         asyncgenerator::PyAsyncGenWrappedValue,
+        frame::stack_analysis,
         function::{PyCell, PyCellRef, PyFunction},
         tuple::{PyTuple, PyTupleRef},
     },
@@ -19,7 +20,7 @@ use crate::{
     object::{Traverse, TraverseFn},
     protocol::{PyIter, PyIterReturn},
     scope::Scope,
-    stdlib::{builtins, typing},
+    stdlib::{builtins, sys::monitoring, typing},
     types::PyTypeFlags,
     vm::{Context, PyMethod},
 };
@@ -28,9 +29,10 @@ use bstr::ByteSlice;
 use core::iter::zip;
 use core::sync::atomic;
 use core::sync::atomic::AtomicPtr;
+use core::sync::atomic::Ordering::Relaxed;
 use indexmap::IndexMap;
 use itertools::Itertools;
-
+use rustpython_common::atomic::{PyAtomic, Radium};
 use rustpython_common::{
     boxvec::BoxVec,
     lock::PyMutex,
@@ -60,9 +62,6 @@ struct FrameState {
     stack: BoxVec<Option<PyObjectRef>>,
     /// Cell and free variable references (cellvars + freevars).
     cells_frees: Box<[PyCellRef]>,
-    /// index of last instruction ran
-    #[cfg(feature = "threading")]
-    lasti: u32,
 }
 
 /// Tracks who owns a frame.
@@ -89,11 +88,6 @@ impl FrameOwner {
     }
 }
 
-#[cfg(feature = "threading")]
-type Lasti = atomic::AtomicU32;
-#[cfg(not(feature = "threading"))]
-type Lasti = core::cell::Cell<u32>;
-
 #[pyclass(module = false, name = "frame", traverse = "manual")]
 pub struct Frame {
     pub code: PyRef<PyCode>,
@@ -104,10 +98,8 @@ pub struct Frame {
     pub globals: PyDictRef,
     pub builtins: PyObjectRef,
 
-    // on feature=threading, this is a duplicate of FrameState.lasti, but it's faster to do an
-    // atomic store than it is to do a fetch_add, for every instruction executed
     /// index of last instruction ran
-    pub lasti: Lasti,
+    pub lasti: PyAtomic<u32>,
     /// tracer function for this frame (usually is None)
     pub trace: PyMutex<PyObjectRef>,
     state: PyMutex<FrameState>,
@@ -129,6 +121,14 @@ pub struct Frame {
     pub(crate) owner: atomic::AtomicI8,
     /// Set when f_locals is accessed. Cleared after locals_to_fast() sync.
     pub(crate) locals_dirty: atomic::AtomicBool,
+    /// Number of stack entries to pop after set_f_lineno returns to the
+    /// execution loop.  set_f_lineno cannot pop directly because the
+    /// execution loop holds the state mutex.
+    pub(crate) pending_stack_pops: PyAtomic<u32>,
+    /// The encoded stack state that set_f_lineno wants to unwind *from*.
+    /// Used together with `pending_stack_pops` to identify Except entries
+    /// that need special exception-state handling.
+    pub(crate) pending_unwind_from_stack: PyAtomic<i64>,
 }
 
 impl PyPayload for Frame {
@@ -200,8 +200,6 @@ impl Frame {
         let state = FrameState {
             stack: BoxVec::new(code.max_stackdepth as usize),
             cells_frees,
-            #[cfg(feature = "threading")]
-            lasti: 0,
         };
 
         Self {
@@ -211,7 +209,7 @@ impl Frame {
             builtins,
             code,
             func_obj,
-            lasti: Lasti::new(0),
+            lasti: Radium::new(0),
             state: PyMutex::new(state),
             trace: PyMutex::new(vm.ctx.none()),
             trace_lines: PyMutex::new(true),
@@ -221,6 +219,8 @@ impl Frame {
             previous: AtomicPtr::new(core::ptr::null_mut()),
             owner: atomic::AtomicI8::new(FrameOwner::FrameObject as i8),
             locals_dirty: atomic::AtomicBool::new(false),
+            pending_stack_pops: Default::default(),
+            pending_unwind_from_stack: Default::default(),
         }
     }
 
@@ -283,14 +283,27 @@ impl Frame {
     }
 
     pub fn lasti(&self) -> u32 {
-        #[cfg(feature = "threading")]
-        {
-            self.lasti.load(atomic::Ordering::Relaxed)
-        }
-        #[cfg(not(feature = "threading"))]
-        {
-            self.lasti.get()
-        }
+        self.lasti.load(Relaxed)
+    }
+
+    pub fn set_lasti(&self, val: u32) {
+        self.lasti.store(val, Relaxed);
+    }
+
+    pub(crate) fn pending_stack_pops(&self) -> u32 {
+        self.pending_stack_pops.load(Relaxed)
+    }
+
+    pub(crate) fn set_pending_stack_pops(&self, val: u32) {
+        self.pending_stack_pops.store(val, Relaxed);
+    }
+
+    pub(crate) fn pending_unwind_from_stack(&self) -> i64 {
+        self.pending_unwind_from_stack.load(Relaxed)
+    }
+
+    pub(crate) fn set_pending_unwind_from_stack(&self, val: i64) {
+        self.pending_unwind_from_stack.store(val, Relaxed);
     }
 
     /// Sync locals dict back to fastlocals. Called before generator/coroutine resume
@@ -369,6 +382,8 @@ impl Py<Frame> {
             lasti: &self.lasti,
             object: self,
             state: &mut state,
+            monitoring_mask: 0,
+            prev_line: 0,
         };
         f(exec)
     }
@@ -414,6 +429,8 @@ impl Py<Frame> {
             lasti: &self.lasti,
             object: self,
             state: &mut state,
+            monitoring_mask: 0,
+            prev_line: 0,
         };
         exec.yield_from_target().map(PyObject::to_owned)
     }
@@ -446,8 +463,12 @@ struct ExecutingFrame<'a> {
     globals: &'a PyDictRef,
     builtins: &'a PyObjectRef,
     object: &'a Py<Frame>,
-    lasti: &'a Lasti,
+    lasti: &'a PyAtomic<u32>,
     state: &'a mut FrameState,
+    /// Cached monitoring events mask. Reloaded at Resume instruction only,
+    monitoring_mask: u32,
+    /// Previous line number for LINE event suppression.
+    prev_line: u32,
 }
 
 impl fmt::Debug for ExecutingFrame<'_> {
@@ -463,29 +484,37 @@ impl fmt::Debug for ExecutingFrame<'_> {
 impl ExecutingFrame<'_> {
     #[inline(always)]
     fn update_lasti(&mut self, f: impl FnOnce(&mut u32)) {
-        #[cfg(feature = "threading")]
-        {
-            f(&mut self.state.lasti);
-            self.lasti
-                .store(self.state.lasti, atomic::Ordering::Relaxed);
-        }
-        #[cfg(not(feature = "threading"))]
-        {
-            let mut lasti = self.lasti.get();
-            f(&mut lasti);
-            self.lasti.set(lasti);
-        }
+        let mut val = self.lasti.load(Relaxed);
+        f(&mut val);
+        self.lasti.store(val, Relaxed);
     }
 
     #[inline(always)]
-    const fn lasti(&self) -> u32 {
-        #[cfg(feature = "threading")]
-        {
-            self.state.lasti
-        }
-        #[cfg(not(feature = "threading"))]
-        {
-            self.lasti.get()
+    fn lasti(&self) -> u32 {
+        self.lasti.load(Relaxed)
+    }
+
+    /// Perform deferred stack unwinding after set_f_lineno.
+    ///
+    /// set_f_lineno cannot pop the value stack directly because the execution
+    /// loop holds the state mutex.  Instead it records the work in
+    /// `pending_stack_pops` / `pending_unwind_from_stack` and we execute it
+    /// here, inside the execution loop where we already own the state.
+    fn unwind_stack_for_lineno(&mut self, pop_count: usize, from_stack: i64, vm: &VirtualMachine) {
+        let mut cur_stack = from_stack;
+        for _ in 0..pop_count {
+            let val = self.pop_value_opt();
+            if stack_analysis::top_of_stack(cur_stack) == stack_analysis::Kind::Except as i64
+                && let Some(exc_obj) = val
+            {
+                if vm.is_none(&exc_obj) {
+                    vm.set_exception(None);
+                } else {
+                    let exc = exc_obj.downcast::<PyBaseException>().ok();
+                    vm.set_exception(exc);
+                }
+            }
+            cur_stack = stack_analysis::pop_value(cur_stack);
         }
     }
 
@@ -497,24 +526,58 @@ impl ExecutingFrame<'_> {
         // Execute until return or exception:
         let instructions = &self.code.instructions;
         let mut arg_state = bytecode::OpArgState::default();
-        let mut prev_line: u32 = 0;
         loop {
             let idx = self.lasti() as usize;
+            // Advance lasti past the current instruction BEFORE firing the
+            // line event.  This ensures that f_lineno (which reads
+            // locations[lasti - 1]) returns the line of the instruction
+            // being traced, not the previous one.
+            self.update_lasti(|i| *i += 1);
+
             // Fire 'line' trace event when line number changes.
             // Only fire if this frame has a per-frame trace function set
             // (frames entered before sys.settrace() have trace=None).
+            // Skip RESUME – it should not generate user-visible line events.
             if vm.use_tracing.get()
                 && !vm.is_none(&self.object.trace.lock())
+                && !matches!(
+                    instructions.get(idx).map(|u| u.op),
+                    Some(Instruction::Resume { .. } | Instruction::InstrumentedResume)
+                )
                 && let Some((loc, _)) = self.code.locations.get(idx)
-                && loc.line.get() as u32 != prev_line
+                && loc.line.get() as u32 != self.prev_line
             {
-                prev_line = loc.line.get() as u32;
+                self.prev_line = loc.line.get() as u32;
                 vm.trace_event(crate::protocol::TraceEvent::Line, None)?;
+                // Trace callback may have changed lasti via set_f_lineno.
+                // Re-read and restart the loop from the new position.
+                if self.lasti() != (idx as u32 + 1) {
+                    // set_f_lineno defers stack unwinding because we hold
+                    // the state mutex.  Perform it now.
+                    let pops = self.object.pending_stack_pops();
+                    if pops > 0 {
+                        let from_stack = self.object.pending_unwind_from_stack();
+                        self.unwind_stack_for_lineno(pops as usize, from_stack, vm);
+                        self.object.set_pending_stack_pops(0);
+                    }
+                    arg_state.reset();
+                    continue;
+                }
             }
-            self.update_lasti(|i| *i += 1);
             let bytecode::CodeUnit { op, arg } = instructions[idx];
             let arg = arg_state.extend(arg);
             let mut do_extend_arg = false;
+
+            if !matches!(
+                op,
+                Instruction::Resume { .. }
+                    | Instruction::ExtendedArg
+                    | Instruction::InstrumentedLine
+            ) && let Some((loc, _)) = self.code.locations.get(idx)
+            {
+                self.prev_line = loc.line.get() as u32;
+            }
+
             let result = self.execute_instruction(op, arg, &mut do_extend_arg, vm);
             match result {
                 Ok(None) => {}
@@ -601,10 +664,52 @@ impl ExecutingFrame<'_> {
                             )
                     );
 
+                    // Fire RAISE or RERAISE monitoring event.
+                    // If the callback raises, replace the original exception.
+                    let exception = {
+                        let mon_events = vm.state.monitoring_events.load();
+                        if is_reraise {
+                            if mon_events & monitoring::EVENT_RERAISE != 0 {
+                                let offset = idx as u32 * 2;
+                                let exc_obj: PyObjectRef = exception.clone().into();
+                                match monitoring::fire_reraise(vm, self.code, offset, &exc_obj) {
+                                    Ok(()) => exception,
+                                    Err(monitor_exc) => monitor_exc,
+                                }
+                            } else {
+                                exception
+                            }
+                        } else if mon_events & monitoring::EVENT_RAISE != 0 {
+                            let offset = idx as u32 * 2;
+                            let exc_obj: PyObjectRef = exception.clone().into();
+                            match monitoring::fire_raise(vm, self.code, offset, &exc_obj) {
+                                Ok(()) => exception,
+                                Err(monitor_exc) => monitor_exc,
+                            }
+                        } else {
+                            exception
+                        }
+                    };
+
                     match handle_exception(self, exception, idx, is_reraise, is_new_raise, vm) {
                         Ok(None) => {}
                         Ok(Some(result)) => break Ok(result),
                         Err(exception) => {
+                            // Fire PY_UNWIND: exception escapes this frame
+                            let exception = if vm.state.monitoring_events.load()
+                                & monitoring::EVENT_PY_UNWIND
+                                != 0
+                            {
+                                let offset = idx as u32 * 2;
+                                let exc_obj: PyObjectRef = exception.clone().into();
+                                match monitoring::fire_py_unwind(vm, self.code, offset, &exc_obj) {
+                                    Ok(()) => exception,
+                                    Err(monitor_exc) => monitor_exc,
+                                }
+                            } else {
+                                exception
+                            };
+
                             // Restore lasti from traceback so frame.f_lineno matches tb_lineno
                             // The traceback was created with the correct lasti when exception
                             // was first raised, but frame.lasti may have changed during cleanup
@@ -671,6 +776,7 @@ impl ExecutingFrame<'_> {
         exc_val: PyObjectRef,
         exc_tb: PyObjectRef,
     ) -> PyResult<ExecutionResult> {
+        self.monitoring_mask = vm.state.monitoring_events.load();
         if let Some(jen) = self.yield_from_target() {
             // Check if the exception is GeneratorExit (type or instance).
             // For GeneratorExit, close the sub-iterator instead of throwing.
@@ -781,6 +887,32 @@ impl ExecutingFrame<'_> {
             exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
         }
 
+        // Fire PY_THROW and RAISE events before raising the exception.
+        // If a monitoring callback fails, its exception replaces the original.
+        let exception = {
+            let mon_events = vm.state.monitoring_events.load();
+            let exception = if mon_events & monitoring::EVENT_PY_THROW != 0 {
+                let offset = idx as u32 * 2;
+                let exc_obj: PyObjectRef = exception.clone().into();
+                match monitoring::fire_py_throw(vm, self.code, offset, &exc_obj) {
+                    Ok(()) => exception,
+                    Err(monitor_exc) => monitor_exc,
+                }
+            } else {
+                exception
+            };
+            if mon_events & monitoring::EVENT_RAISE != 0 {
+                let offset = idx as u32 * 2;
+                let exc_obj: PyObjectRef = exception.clone().into();
+                match monitoring::fire_raise(vm, self.code, offset, &exc_obj) {
+                    Ok(()) => exception,
+                    Err(monitor_exc) => monitor_exc,
+                }
+            } else {
+                exception
+            }
+        };
+
         // when raising an exception, set __context__ to the current exception
         // This is done in _PyErr_SetObject
         vm.contextualize_exception(&exception);
@@ -792,7 +924,21 @@ impl ExecutingFrame<'_> {
         match self.unwind_blocks(vm, UnwindReason::Raising { exception }) {
             Ok(None) => self.run(vm),
             Ok(Some(result)) => Ok(result),
-            Err(exception) => Err(exception),
+            Err(exception) => {
+                // Fire PY_UNWIND: exception escapes the generator frame.
+                let exception =
+                    if vm.state.monitoring_events.load() & monitoring::EVENT_PY_UNWIND != 0 {
+                        let offset = idx as u32 * 2;
+                        let exc_obj: PyObjectRef = exception.clone().into();
+                        match monitoring::fire_py_unwind(vm, self.code, offset, &exc_obj) {
+                            Ok(()) => exception,
+                            Err(monitor_exc) => monitor_exc,
+                        }
+                    } else {
+                        exception
+                    };
+                Err(exception)
+            }
         }
     }
 
@@ -1195,7 +1341,10 @@ impl ExecutingFrame<'_> {
                 *extend_arg = true;
                 Ok(None)
             }
-            Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            Instruction::ForIter { target } => {
+                self.execute_for_iter(vm, target.get(arg))?;
+                Ok(None)
+            }
             Instruction::FormatSimple => {
                 let value = self.pop_value();
                 let formatted = vm.format(&value, vm.ctx.new_str(""))?;
@@ -1941,8 +2090,6 @@ impl ExecutingFrame<'_> {
             Instruction::Nop => Ok(None),
             // NOT_TAKEN is a branch prediction hint - functionally a NOP
             Instruction::NotTaken => Ok(None),
-            // Instrumented version of NOT_TAKEN - NOP without monitoring
-            Instruction::InstrumentedNotTaken => Ok(None),
             // CACHE is used by adaptive interpreter for inline caching - NOP for us
             Instruction::Cache => Ok(None),
             Instruction::ReturnGenerator => {
@@ -2009,16 +2156,25 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
-            Instruction::Resume { arg: resume_arg } => {
-                // Resume execution after yield, await, or at function start
-                // In CPython, this checks instrumentation and eval breaker
-                // For now, we just check for signals/interrupts
-                let _resume_type = resume_arg.get(arg);
-
-                // Check for interrupts if not resuming from yield_from
-                // if resume_type < bytecode::ResumeType::AfterYieldFrom as u32 {
-                //     vm.check_signals()?;
-                // }
+            Instruction::Resume { .. } => {
+                // Check if bytecode needs re-instrumentation
+                let global_ver = vm
+                    .state
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                let code_ver = self
+                    .code
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                if code_ver != global_ver {
+                    let events = vm.state.monitoring_events.load();
+                    monitoring::instrument_code(self.code, events);
+                    self.code
+                        .instrumentation_version
+                        .store(global_ver, atomic::Ordering::Release);
+                    // Re-execute this instruction (it may now be INSTRUMENTED_RESUME)
+                    self.update_lasti(|i| *i -= 1);
+                }
                 Ok(None)
             }
             Instruction::ReturnValue => {
@@ -2350,6 +2506,359 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(!value).into());
                 Ok(None)
             }
+            // All INSTRUMENTED_* opcodes delegate to a cold function to keep
+            // the hot instruction loop free of monitoring overhead.
+            _ => self.execute_instrumented(instruction, arg, vm),
+        }
+    }
+
+    /// Handle all INSTRUMENTED_* opcodes. This function is cold — it only
+    /// runs when sys.monitoring has rewritten the bytecode.
+    #[cold]
+    fn execute_instrumented(
+        &mut self,
+        instruction: Instruction,
+        arg: bytecode::OpArg,
+        vm: &VirtualMachine,
+    ) -> FrameResult {
+        debug_assert!(
+            instruction.is_instrumented(),
+            "execute_instrumented called with non-instrumented opcode {instruction:?}"
+        );
+        self.monitoring_mask = vm.state.monitoring_events.load();
+        match instruction {
+            Instruction::InstrumentedResume => {
+                // Version check: re-instrument if stale
+                let global_ver = vm
+                    .state
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                let code_ver = self
+                    .code
+                    .instrumentation_version
+                    .load(atomic::Ordering::Acquire);
+                if code_ver != global_ver {
+                    let events = vm.state.monitoring_events.load();
+                    monitoring::instrument_code(self.code, events);
+                    self.code
+                        .instrumentation_version
+                        .store(global_ver, atomic::Ordering::Release);
+                    // Re-execute (may have been de-instrumented to base Resume)
+                    self.update_lasti(|i| *i -= 1);
+                    return Ok(None);
+                }
+                let resume_type = u32::from(arg);
+                let offset = (self.lasti() - 1) * 2;
+                if resume_type == 0 {
+                    if self.monitoring_mask & monitoring::EVENT_PY_START != 0 {
+                        monitoring::fire_py_start(vm, self.code, offset)?;
+                    }
+                } else if self.monitoring_mask & monitoring::EVENT_PY_RESUME != 0 {
+                    monitoring::fire_py_resume(vm, self.code, offset)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedReturnValue => {
+                let value = self.pop_value();
+                if self.monitoring_mask & monitoring::EVENT_PY_RETURN != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_py_return(vm, self.code, offset, &value)?;
+                }
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
+            }
+            Instruction::InstrumentedYieldValue => {
+                let value = self.pop_value();
+                if self.monitoring_mask & monitoring::EVENT_PY_YIELD != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_py_yield(vm, self.code, offset, &value)?;
+                }
+                let oparg = u32::from(arg);
+                let wrap = oparg == 0;
+                let value = if wrap && self.code.flags.contains(bytecode::CodeFlags::COROUTINE) {
+                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
+                } else {
+                    value
+                };
+                Ok(Some(ExecutionResult::Yield(value)))
+            }
+            Instruction::InstrumentedCall => {
+                let args = self.collect_positional_args(u32::from(arg));
+                self.execute_call_instrumented(args, vm)
+            }
+            Instruction::InstrumentedCallKw => {
+                let args = self.collect_keyword_args(u32::from(arg));
+                self.execute_call_instrumented(args, vm)
+            }
+            Instruction::InstrumentedCallFunctionEx => {
+                let args = self.collect_ex_args(vm)?;
+                self.execute_call_instrumented(args, vm)
+            }
+            Instruction::InstrumentedLoadSuperAttr => {
+                let oparg = bytecode::LoadSuperAttr::from(u32::from(arg));
+                let offset = (self.lasti() - 1) * 2;
+                // Fire CALL event before super() call
+                let call_args = if self.monitoring_mask & monitoring::EVENT_CALL != 0 {
+                    let global_super: PyObjectRef = self.nth_value(2).to_owned();
+                    let arg0 = if oparg.has_class() {
+                        self.nth_value(1).to_owned()
+                    } else {
+                        monitoring::get_missing(vm)
+                    };
+                    monitoring::fire_call(vm, self.code, offset, &global_super, arg0.clone())?;
+                    Some((global_super, arg0))
+                } else {
+                    None
+                };
+                match self.load_super_attr(vm, oparg) {
+                    Ok(result) => {
+                        // Fire C_RETURN on success
+                        if let Some((global_super, arg0)) = call_args {
+                            monitoring::fire_c_return(vm, self.code, offset, &global_super, arg0)?;
+                        }
+                        Ok(result)
+                    }
+                    Err(exc) => {
+                        // Fire C_RAISE on failure
+                        let exc = if let Some((global_super, arg0)) = call_args {
+                            match monitoring::fire_c_raise(
+                                vm,
+                                self.code,
+                                offset,
+                                &global_super,
+                                arg0,
+                            ) {
+                                Ok(()) => exc,
+                                Err(monitor_exc) => monitor_exc,
+                            }
+                        } else {
+                            exc
+                        };
+                        Err(exc)
+                    }
+                }
+            }
+            Instruction::InstrumentedJumpForward | Instruction::InstrumentedJumpBackward => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target = bytecode::Label::from(u32::from(arg));
+                self.jump(target);
+                if self.monitoring_mask & monitoring::EVENT_JUMP != 0 {
+                    monitoring::fire_jump(vm, self.code, src_offset, target.0 * 2)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedForIter => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target = bytecode::Label::from(u32::from(arg));
+                let continued = self.execute_for_iter(vm, target)?;
+                if continued {
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_LEFT != 0 {
+                        let dest_offset = self.lasti() * 2;
+                        monitoring::fire_branch_left(vm, self.code, src_offset, dest_offset)?;
+                    }
+                } else if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                    let dest_offset = self.lasti() * 2;
+                    monitoring::fire_branch_right(vm, self.code, src_offset, dest_offset)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedEndFor => {
+                // Stack: [value, receiver(iter), ...]
+                // PyGen_Check: only fire STOP_ITERATION for generators
+                let is_gen = self
+                    .nth_value(1)
+                    .downcast_ref::<crate::builtins::PyGenerator>()
+                    .is_some();
+                let value = self.pop_value();
+                if is_gen && self.monitoring_mask & monitoring::EVENT_STOP_ITERATION != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_stop_iteration(vm, self.code, offset, &value)?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedEndSend => {
+                let value = self.pop_value();
+                let receiver = self.pop_value();
+                // PyGen_Check || PyCoro_CheckExact
+                let is_gen_or_coro = receiver
+                    .downcast_ref::<crate::builtins::PyGenerator>()
+                    .is_some()
+                    || receiver
+                        .downcast_ref::<crate::builtins::PyCoroutine>()
+                        .is_some();
+                if is_gen_or_coro && self.monitoring_mask & monitoring::EVENT_STOP_ITERATION != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_stop_iteration(vm, self.code, offset, &value)?;
+                }
+                self.push_value(value);
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfTrue => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target = bytecode::Label::from(u32::from(arg));
+                let obj = self.pop_value();
+                let value = obj.try_to_bool(vm)?;
+                if value {
+                    self.jump(target);
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target.0 * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfFalse => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let target = bytecode::Label::from(u32::from(arg));
+                let obj = self.pop_value();
+                let value = obj.try_to_bool(vm)?;
+                if !value {
+                    self.jump(target);
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target.0 * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfNone => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let value = self.pop_value();
+                let target = bytecode::Label::from(u32::from(arg));
+                if vm.is_none(&value) {
+                    self.jump(target);
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target.0 * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopJumpIfNotNone => {
+                let src_offset = (self.lasti() - 1) * 2;
+                let value = self.pop_value();
+                let target = bytecode::Label::from(u32::from(arg));
+                if !vm.is_none(&value) {
+                    self.jump(target);
+                    if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                        monitoring::fire_branch_right(vm, self.code, src_offset, target.0 * 2)?;
+                    }
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedNotTaken => {
+                if self.monitoring_mask & monitoring::EVENT_BRANCH_LEFT != 0 {
+                    let offset = (self.lasti() - 1) * 2;
+                    let dest_offset = self.lasti() * 2;
+                    monitoring::fire_branch_left(
+                        vm,
+                        self.code,
+                        offset.saturating_sub(2),
+                        dest_offset,
+                    )?;
+                }
+                Ok(None)
+            }
+            Instruction::InstrumentedPopIter => {
+                // BRANCH_RIGHT is fired by InstrumentedForIter, not here.
+                self.pop_value();
+                Ok(None)
+            }
+            Instruction::InstrumentedEndAsyncFor => {
+                if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {
+                    let oparg_val = u32::from(arg);
+                    // src = next_instr - oparg (END_SEND position)
+                    let src_offset = (self.lasti() - oparg_val) * 2;
+                    // dest = this_instr + 1
+                    let dest_offset = self.lasti() * 2;
+                    monitoring::fire_branch_right(vm, self.code, src_offset, dest_offset)?;
+                }
+                let exc = self.pop_value();
+                let _awaitable = self.pop_value();
+                let exc = exc
+                    .downcast::<PyBaseException>()
+                    .expect("EndAsyncFor expects exception on stack");
+                if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) {
+                    vm.set_exception(None);
+                    Ok(None)
+                } else {
+                    Err(exc)
+                }
+            }
+            Instruction::InstrumentedLine => {
+                let idx = self.lasti() as usize - 1;
+                let offset = idx as u32 * 2;
+
+                // Read the full side-table chain before firing any events,
+                // because a callback may de-instrument and clear the tables.
+                let (real_op_byte, also_instruction) = {
+                    let data = self.code.monitoring_data.lock();
+                    let line_op = data.as_ref().map(|d| d.line_opcodes[idx]).unwrap_or(0);
+                    if line_op == u8::from(Instruction::InstrumentedInstruction) {
+                        // LINE wraps INSTRUCTION: resolve the INSTRUCTION side-table too
+                        let inst_op = data
+                            .as_ref()
+                            .map(|d| d.per_instruction_opcodes[idx])
+                            .unwrap_or(0);
+                        (inst_op, true)
+                    } else {
+                        (line_op, false)
+                    }
+                };
+                debug_assert!(
+                    real_op_byte != 0,
+                    "INSTRUMENTED_LINE at {idx} without stored opcode"
+                );
+
+                // Fire LINE event only if line changed
+                if let Some((loc, _)) = self.code.locations.get(idx) {
+                    let line = loc.line.get() as u32;
+                    if line != self.prev_line && line > 0 {
+                        self.prev_line = line;
+                        monitoring::fire_line(vm, self.code, offset, line)?;
+                    }
+                }
+
+                // If the LINE position also had INSTRUCTION, fire that event too
+                if also_instruction {
+                    monitoring::fire_instruction(vm, self.code, offset)?;
+                }
+
+                // Re-dispatch to the real original opcode
+                let original_op = Instruction::try_from(real_op_byte)
+                    .expect("invalid opcode in side-table chain");
+                if original_op.to_base().is_some() {
+                    self.execute_instrumented(original_op, arg, vm)
+                } else {
+                    let mut do_extend_arg = false;
+                    self.execute_instruction(original_op, arg, &mut do_extend_arg, vm)
+                }
+            }
+            Instruction::InstrumentedInstruction => {
+                let idx = self.lasti() as usize - 1;
+                let offset = idx as u32 * 2;
+
+                // Get original opcode from side-table
+                let original_op_byte = {
+                    let data = self.code.monitoring_data.lock();
+                    data.as_ref()
+                        .map(|d| d.per_instruction_opcodes[idx])
+                        .unwrap_or(0)
+                };
+                debug_assert!(
+                    original_op_byte != 0,
+                    "INSTRUMENTED_INSTRUCTION at {idx} without stored opcode"
+                );
+
+                // Fire INSTRUCTION event
+                monitoring::fire_instruction(vm, self.code, offset)?;
+
+                // Re-dispatch to original opcode
+                let original_op = Instruction::try_from(original_op_byte)
+                    .expect("invalid opcode in instruction side-table");
+                if original_op.to_base().is_some() {
+                    self.execute_instrumented(original_op, arg, vm)
+                } else {
+                    let mut do_extend_arg = false;
+                    self.execute_instruction(original_op, arg, &mut do_extend_arg, vm)
+                }
+            }
             _ => {
                 unreachable!("{instruction:?} instruction should not be executed")
             }
@@ -2571,6 +3080,16 @@ impl ExecutingFrame<'_> {
                 if let Some(entry) =
                     bytecode::find_exception_handler(&self.code.exceptiontable, offset)
                 {
+                    // Fire EXCEPTION_HANDLED before setting up handler.
+                    // If the callback raises, the handler is NOT set up and the
+                    // new exception propagates instead.
+                    if vm.state.monitoring_events.load() & monitoring::EVENT_EXCEPTION_HANDLED != 0
+                    {
+                        let byte_offset = offset * 2;
+                        let exc_obj: PyObjectRef = exception.clone().into();
+                        monitoring::fire_exception_handled(vm, self.code, byte_offset, &exc_obj)?;
+                    }
+
                     // 1. Pop stack to entry.depth
                     while self.state.stack.len() > entry.depth as usize {
                         self.state.stack.pop();
@@ -2778,9 +3297,7 @@ impl ExecutingFrame<'_> {
         let self_or_null = self.pop_value_opt(); // Option<PyObjectRef>
         let callable = self.pop_value();
 
-        // If self_or_null is Some (not NULL), prepend it to args
         let final_args = if let Some(self_val) = self_or_null {
-            // Method call: prepend self to args
             let mut all_args = vec![self_val];
             all_args.extend(args.args);
             FuncArgs {
@@ -2788,7 +3305,6 @@ impl ExecutingFrame<'_> {
                 kwargs: args.kwargs,
             }
         } else {
-            // Regular attribute call: self_or_null is NULL
             args
         };
 
@@ -2797,6 +3313,66 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
+    /// Instrumented version of execute_call: fires CALL, C_RETURN, and C_RAISE events.
+    fn execute_call_instrumented(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
+        let self_or_null = self.pop_value_opt();
+        let callable = self.pop_value();
+
+        let final_args = if let Some(self_val) = self_or_null {
+            let mut all_args = vec![self_val];
+            all_args.extend(args.args);
+            FuncArgs {
+                args: all_args,
+                kwargs: args.kwargs,
+            }
+        } else {
+            args
+        };
+
+        let is_python_call = callable.downcast_ref::<PyFunction>().is_some();
+
+        // Fire CALL event
+        let call_arg0 = if self.monitoring_mask & monitoring::EVENT_CALL != 0 {
+            let arg0 = final_args
+                .args
+                .first()
+                .cloned()
+                .unwrap_or_else(|| monitoring::get_missing(vm));
+            let offset = (self.lasti() - 1) * 2;
+            monitoring::fire_call(vm, self.code, offset, &callable, arg0.clone())?;
+            Some(arg0)
+        } else {
+            None
+        };
+
+        match callable.call(final_args, vm) {
+            Ok(value) => {
+                if let Some(arg0) = call_arg0
+                    && !is_python_call
+                {
+                    let offset = (self.lasti() - 1) * 2;
+                    monitoring::fire_c_return(vm, self.code, offset, &callable, arg0)?;
+                }
+                self.push_value(value);
+                Ok(None)
+            }
+            Err(exc) => {
+                let exc = if let Some(arg0) = call_arg0
+                    && !is_python_call
+                {
+                    let offset = (self.lasti() - 1) * 2;
+                    match monitoring::fire_c_raise(vm, self.code, offset, &callable, arg0) {
+                        Ok(()) => exc,
+                        Err(monitor_exc) => monitor_exc,
+                    }
+                } else {
+                    exc
+                };
+                Err(exc)
+            }
+        }
+    }
+
     fn execute_raise(&mut self, vm: &VirtualMachine, kind: bytecode::RaiseKind) -> FrameResult {
         let cause = match kind {
             bytecode::RaiseKind::RaiseCause => {
@@ -2938,42 +3514,40 @@ impl ExecutingFrame<'_> {
         Ok(None)
     }
 
-    /// The top of stack contains the iterator, lets push it forward
-    fn execute_for_iter(&mut self, vm: &VirtualMachine, target: bytecode::Label) -> FrameResult {
+    /// Advance the iterator on top of stack.
+    /// Returns `true` if iteration continued (item pushed), `false` if exhausted (jumped).
+    fn execute_for_iter(
+        &mut self,
+        vm: &VirtualMachine,
+        target: bytecode::Label,
+    ) -> Result<bool, PyBaseExceptionRef> {
         let top_of_stack = PyIter::new(self.top_value());
         let next_obj = top_of_stack.next(vm);
 
-        // Check the next object:
         match next_obj {
             Ok(PyIterReturn::Return(value)) => {
                 self.push_value(value);
-                Ok(None)
+                Ok(true)
             }
             Ok(PyIterReturn::StopIteration(_)) => {
-                // Check if target instruction is END_FOR (CPython 3.14 pattern)
-                // If so, skip it and jump to target + 1 instruction (POP_ITER)
+                // Skip END_FOR (base or instrumented) and jump to POP_ITER.
                 let target_idx = target.0 as usize;
                 let jump_target = if let Some(unit) = self.code.instructions.get(target_idx) {
-                    if matches!(unit.op, bytecode::Instruction::EndFor)
-                        && matches!(
-                            self.code.instructions.get(target_idx + 1).map(|u| &u.op),
-                            Some(bytecode::Instruction::PopIter)
-                        )
-                    {
-                        // Skip END_FOR, jump to POP_ITER
+                    if matches!(
+                        unit.op,
+                        bytecode::Instruction::EndFor | bytecode::Instruction::InstrumentedEndFor
+                    ) {
                         bytecode::Label(target.0 + 1)
                     } else {
-                        // Legacy pattern: jump directly to target (POP_TOP/POP_ITER)
                         target
                     }
                 } else {
                     target
                 };
                 self.jump(jump_target);
-                Ok(None)
+                Ok(false)
             }
             Err(next_error) => {
-                // On error, pop iterator and propagate
                 self.pop_value();
                 Err(next_error)
             }
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
index ec21cc7f46e..68734f94631 100644
--- a/crates/vm/src/stdlib/sys.rs
+++ b/crates/vm/src/stdlib/sys.rs
@@ -1,3 +1,5 @@
+pub(crate) mod monitoring;
+
 use crate::{Py, PyPayload, PyResult, VirtualMachine, builtins::PyModule, convert::ToPyObject};
 
 #[cfg(all(not(feature = "host_env"), feature = "stdio"))]
@@ -73,6 +75,9 @@ mod sys {
         RUST_MULTIARCH.replace("-unknown", "")
     }
 
+    #[pymodule(name = "monitoring", with(super::monitoring::sys_monitoring))]
+    pub(super) mod monitoring {}
+
     #[pyclass(no_attr, name = "_BootstrapStderr")]
     #[derive(Debug, PyPayload)]
     pub(super) struct BootstrapStderr;
diff --git a/crates/vm/src/stdlib/sys/monitoring.rs b/crates/vm/src/stdlib/sys/monitoring.rs
new file mode 100644
index 00000000000..05c427357dd
--- /dev/null
+++ b/crates/vm/src/stdlib/sys/monitoring.rs
@@ -0,0 +1,1134 @@
+use crate::{
+    AsObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyCode, PyDictRef, PyNamespace, PyUtf8StrRef, code::CoMonitoringData},
+    function::FuncArgs,
+};
+use core::sync::atomic::Ordering;
+use crossbeam_utils::atomic::AtomicCell;
+use std::collections::{HashMap, HashSet};
+
+pub const TOOL_LIMIT: usize = 6;
+const EVENTS_COUNT: usize = 19;
+const LOCAL_EVENTS_COUNT: usize = 11;
+const UNGROUPED_EVENTS_COUNT: usize = 18;
+
+// Event bit positions
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct MonitoringEvents: u32 {
+        const PY_START           = 1 << 0;
+        const PY_RESUME          = 1 << 1;
+        const PY_RETURN          = 1 << 2;
+        const PY_YIELD           = 1 << 3;
+        const CALL               = 1 << 4;
+        const LINE               = 1 << 5;
+        const INSTRUCTION        = 1 << 6;
+        const JUMP               = 1 << 7;
+        const BRANCH_LEFT        = 1 << 8;
+        const BRANCH_RIGHT       = 1 << 9;
+        const STOP_ITERATION     = 1 << 10;
+        const RAISE              = 1 << 11;
+        const EXCEPTION_HANDLED  = 1 << 12;
+        const PY_UNWIND          = 1 << 13;
+        const PY_THROW           = 1 << 14;
+        const RERAISE            = 1 << 15;
+        const C_RETURN           = 1 << 16;
+        const C_RAISE            = 1 << 17;
+        const BRANCH             = 1 << 18;
+    }
+}
+
+// Re-export as plain u32 constants for use in frame.rs hot-path checks
+pub const EVENT_PY_START: u32 = MonitoringEvents::PY_START.bits();
+pub const EVENT_PY_RESUME: u32 = MonitoringEvents::PY_RESUME.bits();
+pub const EVENT_PY_RETURN: u32 = MonitoringEvents::PY_RETURN.bits();
+pub const EVENT_PY_YIELD: u32 = MonitoringEvents::PY_YIELD.bits();
+pub const EVENT_CALL: u32 = MonitoringEvents::CALL.bits();
+pub const EVENT_LINE: u32 = MonitoringEvents::LINE.bits();
+pub const EVENT_INSTRUCTION: u32 = MonitoringEvents::INSTRUCTION.bits();
+pub const EVENT_JUMP: u32 = MonitoringEvents::JUMP.bits();
+pub const EVENT_BRANCH_LEFT: u32 = MonitoringEvents::BRANCH_LEFT.bits();
+pub const EVENT_BRANCH_RIGHT: u32 = MonitoringEvents::BRANCH_RIGHT.bits();
+pub const EVENT_RAISE: u32 = MonitoringEvents::RAISE.bits();
+pub const EVENT_EXCEPTION_HANDLED: u32 = MonitoringEvents::EXCEPTION_HANDLED.bits();
+pub const EVENT_PY_UNWIND: u32 = MonitoringEvents::PY_UNWIND.bits();
+pub const EVENT_C_RETURN: u32 = MonitoringEvents::C_RETURN.bits();
+const EVENT_C_RAISE: u32 = MonitoringEvents::C_RAISE.bits();
+pub const EVENT_STOP_ITERATION: u32 = MonitoringEvents::STOP_ITERATION.bits();
+pub const EVENT_PY_THROW: u32 = MonitoringEvents::PY_THROW.bits();
+const EVENT_BRANCH: u32 = MonitoringEvents::BRANCH.bits();
+pub const EVENT_RERAISE: u32 = MonitoringEvents::RERAISE.bits();
+const EVENT_C_RETURN_MASK: u32 = EVENT_C_RETURN | EVENT_C_RAISE;
+
+const EVENT_NAMES: [&str; EVENTS_COUNT] = [
+    "PY_START",
+    "PY_RESUME",
+    "PY_RETURN",
+    "PY_YIELD",
+    "CALL",
+    "LINE",
+    "INSTRUCTION",
+    "JUMP",
+    "BRANCH_LEFT",
+    "BRANCH_RIGHT",
+    "STOP_ITERATION",
+    "RAISE",
+    "EXCEPTION_HANDLED",
+    "PY_UNWIND",
+    "PY_THROW",
+    "RERAISE",
+    "C_RETURN",
+    "C_RAISE",
+    "BRANCH",
+];
+
+/// Interpreter-level monitoring state, shared by all threads.
+pub struct MonitoringState {
+    pub tool_names: [Option<String>; TOOL_LIMIT],
+    pub global_events: [u32; TOOL_LIMIT],
+    pub local_events: HashMap<(usize, usize), u32>,
+    pub callbacks: HashMap<(usize, usize), PyObjectRef>,
+    /// Per-instruction disabled tools: (code_id, offset, tool)
+    pub disabled: HashSet<(usize, usize, usize)>,
+    /// Cached MISSING sentinel singleton
+    pub missing: Option<PyObjectRef>,
+    /// Cached DISABLE sentinel singleton
+    pub disable: Option<PyObjectRef>,
+}
+
+impl Default for MonitoringState {
+    fn default() -> Self {
+        Self {
+            tool_names: Default::default(),
+            global_events: [0; TOOL_LIMIT],
+            local_events: HashMap::new(),
+            callbacks: HashMap::new(),
+            disabled: HashSet::new(),
+            missing: None,
+            disable: None,
+        }
+    }
+}
+
+impl MonitoringState {
+    /// Compute the OR of all tools' global_events + local_events.
+    /// This is used for the fast-path atomic mask to skip monitoring
+    /// when no events are registered at all.
+    pub fn combined_events(&self) -> u32 {
+        let global = self.global_events.iter().fold(0, |acc, &e| acc | e);
+        let local = self.local_events.values().fold(0, |acc, &e| acc | e);
+        global | local
+    }
+}
+
+/// Global atomic mask: OR of all tools' events. Checked in the hot path
+/// to skip monitoring overhead when no events are registered.
+/// Lives in PyGlobalState alongside the PyMutex<MonitoringState>.
+pub type MonitoringEventsMask = AtomicCell<u32>;
+
+/// Get the MISSING sentinel, creating it if necessary.
+pub fn get_missing(vm: &VirtualMachine) -> PyObjectRef {
+    let mut state = vm.state.monitoring.lock();
+    if let Some(ref m) = state.missing {
+        m.clone()
+    } else {
+        let m: PyObjectRef = sys_monitoring::MonitoringSentinel.into_ref(&vm.ctx).into();
+        state.missing = Some(m.clone());
+        m
+    }
+}
+
+/// Get the DISABLE sentinel, creating it if necessary.
+pub fn get_disable(vm: &VirtualMachine) -> PyObjectRef {
+    let mut state = vm.state.monitoring.lock();
+    if let Some(ref d) = state.disable {
+        d.clone()
+    } else {
+        let d: PyObjectRef = sys_monitoring::MonitoringSentinel.into_ref(&vm.ctx).into();
+        state.disable = Some(d.clone());
+        d
+    }
+}
+
+fn check_valid_tool(tool_id: i32, vm: &VirtualMachine) -> PyResult<usize> {
+    if !(0..TOOL_LIMIT as i32).contains(&tool_id) {
+        return Err(vm.new_value_error(format!("invalid tool {tool_id} (must be between 0 and 5)")));
+    }
+    Ok(tool_id as usize)
+}
+
+fn check_tool_in_use(tool: usize, vm: &VirtualMachine) -> PyResult<()> {
+    let state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        Ok(())
+    } else {
+        Err(vm.new_value_error(format!("tool {tool} is not in use")))
+    }
+}
+
+fn parse_single_event(event: i32, vm: &VirtualMachine) -> PyResult<usize> {
+    let event = u32::try_from(event)
+        .map_err(|_| vm.new_value_error("The callback can only be set for one event at a time"))?;
+    if event.count_ones() != 1 {
+        return Err(vm.new_value_error("The callback can only be set for one event at a time"));
+    }
+    let event_id = event.trailing_zeros() as usize;
+    if event_id >= EVENTS_COUNT {
+        return Err(vm.new_value_error(format!("invalid event {event}")));
+    }
+    Ok(event_id)
+}
+
+fn normalize_event_set(event_set: i32, local: bool, vm: &VirtualMachine) -> PyResult<u32> {
+    let kind = if local {
+        "local event set"
+    } else {
+        "event set"
+    };
+    if event_set < 0 {
+        return Err(vm.new_value_error(format!("invalid {kind} 0x{event_set:x}")));
+    }
+
+    let mut event_set = event_set as u32;
+    if event_set >= (1 << EVENTS_COUNT) {
+        return Err(vm.new_value_error(format!("invalid {kind} 0x{event_set:x}")));
+    }
+
+    if (event_set & EVENT_C_RETURN_MASK) != 0 && (event_set & EVENT_CALL) != EVENT_CALL {
+        return Err(vm.new_value_error("cannot set C_RETURN or C_RAISE events independently"));
+    }
+
+    event_set &= !EVENT_C_RETURN_MASK;
+
+    if (event_set & EVENT_BRANCH) != 0 {
+        event_set &= !EVENT_BRANCH;
+        event_set |= EVENT_BRANCH_LEFT | EVENT_BRANCH_RIGHT;
+    }
+
+    if local && event_set >= (1 << LOCAL_EVENTS_COUNT) {
+        return Err(vm.new_value_error(format!("invalid local event set 0x{event_set:x}")));
+    }
+
+    Ok(event_set)
+}
+
+/// Rewrite a code object's bytecode in-place with layered instrumentation.
+///
+/// Three layers (outermost first):
+/// 1. INSTRUMENTED_LINE — wraps line-start instructions (stores original in side-table)
+/// 2. INSTRUMENTED_INSTRUCTION — wraps all traceable instructions (stores original in side-table)
+/// 3. Regular INSTRUMENTED_* — direct 1:1 opcode swap (no side-table needed)
+///
+/// De-instrumentation peels layers in reverse order.
+pub fn instrument_code(code: &PyCode, events: u32) {
+    use rustpython_compiler_core::bytecode::{self, Instruction};
+
+    let len = code.code.instructions.len();
+    let mut monitoring_data = code.monitoring_data.lock();
+
+    // === Phase 1-3: De-instrument all layers (outermost first) ===
+
+    // Phase 1: Remove INSTRUMENTED_LINE → restore from side-table
+    if let Some(data) = monitoring_data.as_mut() {
+        for i in 0..len {
+            if data.line_opcodes[i] != 0 {
+                let original = Instruction::try_from(data.line_opcodes[i])
+                    .expect("invalid opcode in line side-table");
+                unsafe {
+                    code.code.instructions.replace_op(i, original);
+                }
+                data.line_opcodes[i] = 0;
+            }
+        }
+    }
+
+    // Phase 2: Remove INSTRUMENTED_INSTRUCTION → restore from side-table
+    if let Some(data) = monitoring_data.as_mut() {
+        for i in 0..len {
+            if data.per_instruction_opcodes[i] != 0 {
+                let original = Instruction::try_from(data.per_instruction_opcodes[i])
+                    .expect("invalid opcode in instruction side-table");
+                unsafe {
+                    code.code.instructions.replace_op(i, original);
+                }
+                data.per_instruction_opcodes[i] = 0;
+            }
+        }
+    }
+
+    // Phase 3: Remove regular INSTRUMENTED_* → restore base opcodes
+    for i in 0..len {
+        let op = code.code.instructions[i].op;
+        if let Some(base) = op.to_base() {
+            unsafe {
+                code.code.instructions.replace_op(i, base);
+            }
+        }
+    }
+
+    // All opcodes are now base opcodes.
+
+    if events == 0 {
+        *monitoring_data = None;
+        return;
+    }
+
+    // === Phase 4-6: Re-instrument (innermost first) ===
+
+    // Ensure monitoring data exists
+    if monitoring_data.is_none() {
+        *monitoring_data = Some(CoMonitoringData {
+            line_opcodes: vec![0u8; len],
+            per_instruction_opcodes: vec![0u8; len],
+        });
+    }
+    let data = monitoring_data.as_mut().unwrap();
+    // Resize if code length changed (shouldn't happen, but be safe)
+    data.line_opcodes.resize(len, 0);
+    data.per_instruction_opcodes.resize(len, 0);
+
+    // Find _co_firsttraceable: index of first RESUME instruction
+    let first_traceable = code
+        .code
+        .instructions
+        .iter()
+        .position(|u| matches!(u.op, Instruction::Resume { .. }))
+        .unwrap_or(0);
+
+    // Phase 4: Place regular INSTRUMENTED_* opcodes
+    for i in 0..len {
+        let op = code.code.instructions[i].op;
+        if let Some(instrumented) = op.to_instrumented() {
+            unsafe {
+                code.code.instructions.replace_op(i, instrumented);
+            }
+        }
+    }
+
+    // Phase 5: Place INSTRUMENTED_INSTRUCTION (if EVENT_INSTRUCTION is active)
+    if events & EVENT_INSTRUCTION != 0 {
+        for i in first_traceable..len {
+            let op = code.code.instructions[i].op;
+            // Skip ExtendedArg
+            if matches!(op, Instruction::ExtendedArg) {
+                continue;
+            }
+            // Excluded: RESUME and END_FOR (and their instrumented variants)
+            let base = op.to_base().map_or(op, |b| b);
+            if matches!(base, Instruction::Resume { .. } | Instruction::EndFor) {
+                continue;
+            }
+            // Store current opcode (may already be INSTRUMENTED_*) and replace
+            data.per_instruction_opcodes[i] = u8::from(op);
+            unsafe {
+                code.code
+                    .instructions
+                    .replace_op(i, Instruction::InstrumentedInstruction);
+            }
+        }
+    }
+
+    // Phase 6: Place INSTRUMENTED_LINE (if EVENT_LINE is active)
+    // Mirrors CPython's initialize_lines: first determine which positions
+    // are line starts, then mark branch/jump targets, then place opcodes.
+    if events & EVENT_LINE != 0 {
+        // is_line_start[i] = true if position i should have INSTRUMENTED_LINE
+        let mut is_line_start = vec![false; len];
+
+        // First pass: mark positions where the source line changes
+        let mut prev_line: Option<u32> = None;
+        for (i, unit) in code
+            .code
+            .instructions
+            .iter()
+            .enumerate()
+            .take(len)
+            .skip(first_traceable)
+        {
+            let op = unit.op;
+            let base = op.to_base().map_or(op, |b| b);
+            if matches!(base, Instruction::ExtendedArg) {
+                continue;
+            }
+            // Excluded opcodes
+            if matches!(
+                base,
+                Instruction::Resume { .. }
+                    | Instruction::EndFor
+                    | Instruction::EndSend
+                    | Instruction::PopIter
+                    | Instruction::EndAsyncFor
+            ) {
+                continue;
+            }
+            if let Some((loc, _)) = code.code.locations.get(i) {
+                let line = loc.line.get() as u32;
+                let is_new = prev_line != Some(line);
+                prev_line = Some(line);
+                if is_new && line > 0 {
+                    is_line_start[i] = true;
+                }
+            }
+        }
+
+        // Second pass: mark branch/jump targets as line starts.
+        // Every jump/branch target must be a line start, even if on the
+        // same source line as the preceding instruction. Critical for loops
+        // (JUMP_BACKWARD → FOR_ITER).
+        let mut arg_state = bytecode::OpArgState::default();
+        for unit in code.code.instructions[first_traceable..len].iter().copied() {
+            let (op, arg) = arg_state.get(unit);
+            let base = op.to_base().map_or(op, |b| b);
+
+            if matches!(base, Instruction::ExtendedArg) {
+                continue;
+            }
+
+            let target: Option<usize> = match base {
+                Instruction::PopJumpIfFalse { .. }
+                | Instruction::PopJumpIfTrue { .. }
+                | Instruction::PopJumpIfNone { .. }
+                | Instruction::PopJumpIfNotNone { .. }
+                | Instruction::JumpForward { .. }
+                | Instruction::JumpBackward { .. }
+                | Instruction::JumpBackwardNoInterrupt { .. } => Some(u32::from(arg) as usize),
+                Instruction::ForIter { .. } | Instruction::Send { .. } => {
+                    // Skip over END_FOR/END_SEND
+                    Some(u32::from(arg) as usize + 1)
+                }
+                _ => None,
+            };
+
+            if let Some(target_idx) = target
+                && target_idx < len
+                && !is_line_start[target_idx]
+            {
+                let target_op = code.code.instructions[target_idx].op;
+                let target_base = target_op.to_base().map_or(target_op, |b| b);
+                // Skip POP_ITER targets
+                if matches!(target_base, Instruction::PopIter) {
+                    continue;
+                }
+                if let Some((loc, _)) = code.code.locations.get(target_idx)
+                    && loc.line.get() > 0
+                {
+                    is_line_start[target_idx] = true;
+                }
+            }
+        }
+
+        // Third pass: mark exception handler targets as line starts.
+        for entry in bytecode::decode_exception_table(&code.code.exceptiontable) {
+            let target_idx = entry.target as usize;
+            if target_idx < len && !is_line_start[target_idx] {
+                let target_op = code.code.instructions[target_idx].op;
+                let target_base = target_op.to_base().map_or(target_op, |b| b);
+                if !matches!(target_base, Instruction::PopIter)
+                    && let Some((loc, _)) = code.code.locations.get(target_idx)
+                    && loc.line.get() > 0
+                {
+                    is_line_start[target_idx] = true;
+                }
+            }
+        }
+
+        // Fourth pass: actually place INSTRUMENTED_LINE at all marked positions
+        for (i, marked) in is_line_start
+            .iter()
+            .copied()
+            .enumerate()
+            .take(len)
+            .skip(first_traceable)
+        {
+            if marked {
+                let op = code.code.instructions[i].op;
+                data.line_opcodes[i] = u8::from(op);
+                unsafe {
+                    code.code
+                        .instructions
+                        .replace_op(i, Instruction::InstrumentedLine);
+                }
+            }
+        }
+    }
+}
+
+/// Update the global monitoring_events atomic mask from current state.
+fn update_events_mask(vm: &VirtualMachine, state: &MonitoringState) {
+    let events = state.combined_events();
+    vm.state.monitoring_events.store(events);
+    let new_ver = vm
+        .state
+        .instrumentation_version
+        .fetch_add(1, Ordering::Release)
+        + 1;
+    // Eagerly re-instrument all frames on the current thread's stack so that
+    // code objects already past their RESUME pick up the new event set.
+    for fp in vm.frames.borrow().iter() {
+        // SAFETY: frames in the Vec are alive while their FrameRef is on the call stack.
+        let frame = unsafe { fp.as_ref() };
+        let code = &frame.code;
+        let code_ver = code.instrumentation_version.load(Ordering::Acquire);
+        if code_ver != new_ver {
+            instrument_code(code, events);
+            code.instrumentation_version
+                .store(new_ver, Ordering::Release);
+        }
+    }
+}
+
+fn use_tool_id(tool_id: i32, name: &str, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        return Err(vm.new_value_error(format!("tool {tool_id} is already in use")));
+    }
+    state.tool_names[tool] = Some(name.to_owned());
+    Ok(())
+}
+
+fn clear_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        state.global_events[tool] = 0;
+        state
+            .local_events
+            .retain(|(local_tool, _), _| *local_tool != tool);
+        state.callbacks.retain(|(cb_tool, _), _| *cb_tool != tool);
+        state.disabled.retain(|&(_, _, t)| t != tool);
+    }
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn free_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    if state.tool_names[tool].is_some() {
+        state.global_events[tool] = 0;
+        state
+            .local_events
+            .retain(|(local_tool, _), _| *local_tool != tool);
+        state.callbacks.retain(|(cb_tool, _), _| *cb_tool != tool);
+        state.disabled.retain(|&(_, _, t)| t != tool);
+        state.tool_names[tool] = None;
+    }
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn get_tool(tool_id: i32, vm: &VirtualMachine) -> PyResult<Option<String>> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let state = vm.state.monitoring.lock();
+    Ok(state.tool_names[tool].clone())
+}
+
+fn register_callback(
+    tool_id: i32,
+    event: i32,
+    func: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<PyObjectRef> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let event_id = parse_single_event(event, vm)?;
+
+    let mut state = vm.state.monitoring.lock();
+    let prev = state
+        .callbacks
+        .remove(&(tool, event_id))
+        .unwrap_or_else(|| vm.ctx.none());
+    let branch_id = EVENT_BRANCH.trailing_zeros() as usize;
+    let branch_left_id = EVENT_BRANCH_LEFT.trailing_zeros() as usize;
+    let branch_right_id = EVENT_BRANCH_RIGHT.trailing_zeros() as usize;
+    if !vm.is_none(&func) {
+        state.callbacks.insert((tool, event_id), func.clone());
+        // BRANCH is a composite event: also register for BRANCH_LEFT/RIGHT
+        if event_id == branch_id {
+            state.callbacks.insert((tool, branch_left_id), func.clone());
+            state.callbacks.insert((tool, branch_right_id), func);
+        }
+    } else {
+        // Also clear BRANCH_LEFT/RIGHT when clearing BRANCH
+        if event_id == branch_id {
+            state.callbacks.remove(&(tool, branch_left_id));
+            state.callbacks.remove(&(tool, branch_right_id));
+        }
+    }
+    Ok(prev)
+}
+
+fn get_events(tool_id: i32, vm: &VirtualMachine) -> PyResult<u32> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    let state = vm.state.monitoring.lock();
+    Ok(state.global_events[tool])
+}
+
+fn set_events(tool_id: i32, event_set: i32, vm: &VirtualMachine) -> PyResult<()> {
+    let tool = check_valid_tool(tool_id, vm)?;
+    check_tool_in_use(tool, vm)?;
+    let normalized = normalize_event_set(event_set, false, vm)?;
+    let mut state = vm.state.monitoring.lock();
+    state.global_events[tool] = normalized;
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn get_local_events(tool_id: i32, code: PyObjectRef, vm: &VirtualMachine) -> PyResult<u32> {
+    if code.downcast_ref::<PyCode>().is_none() {
+        return Err(vm.new_type_error("code must be a code object"));
+    }
+    let tool = check_valid_tool(tool_id, vm)?;
+    let code_id = code.get_id();
+    let state = vm.state.monitoring.lock();
+    Ok(state
+        .local_events
+        .get(&(tool, code_id))
+        .copied()
+        .unwrap_or(0))
+}
+
+fn set_local_events(
+    tool_id: i32,
+    code: PyObjectRef,
+    event_set: i32,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    if code.downcast_ref::<PyCode>().is_none() {
+        return Err(vm.new_type_error("code must be a code object"));
+    }
+    let tool = check_valid_tool(tool_id, vm)?;
+    check_tool_in_use(tool, vm)?;
+    let normalized = normalize_event_set(event_set, true, vm)?;
+    let code_id = code.get_id();
+    let mut state = vm.state.monitoring.lock();
+    if normalized == 0 {
+        state.local_events.remove(&(tool, code_id));
+    } else {
+        state.local_events.insert((tool, code_id), normalized);
+    }
+    update_events_mask(vm, &state);
+    Ok(())
+}
+
+fn restart_events(vm: &VirtualMachine) {
+    let mut state = vm.state.monitoring.lock();
+    state.disabled.clear();
+}
+
+fn all_events(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+    // Collect data under the lock, then release before calling into Python VM.
+    let masks: Vec<(&str, u8)> = {
+        let state = vm.state.monitoring.lock();
+        EVENT_NAMES
+            .iter()
+            .take(UNGROUPED_EVENTS_COUNT)
+            .enumerate()
+            .filter_map(|(event_id, event_name)| {
+                let event_bit = 1u32 << event_id;
+                let mut tools_mask = 0u8;
+                for tool in 0..TOOL_LIMIT {
+                    if (state.global_events[tool] & event_bit) != 0 {
+                        tools_mask |= 1 << tool;
+                    }
+                }
+                if tools_mask != 0 {
+                    Some((*event_name, tools_mask))
+                } else {
+                    None
+                }
+            })
+            .collect()
+    };
+    let all_events = vm.ctx.new_dict();
+    for (name, mask) in masks {
+        all_events.set_item(name, vm.ctx.new_int(mask).into(), vm)?;
+    }
+    Ok(all_events)
+}
+
+// Event dispatch
+
+use core::cell::Cell;
+
+thread_local! {
+    /// Re-entrancy guard: prevents monitoring callbacks from triggering
+    /// additional monitoring events (which would cause infinite recursion).
+    static FIRING: Cell<bool> = const { Cell::new(false) };
+
+    /// Tracks whether a RERAISE event has been fired since the last
+    /// EXCEPTION_HANDLED. Used to suppress duplicate RERAISE from
+    /// cleanup handlers that chain through multiple exception table entries.
+    static RERAISE_PENDING: Cell<bool> = const { Cell::new(false) };
+}
+
+/// Fire an event for all tools that have the event bit set.
+/// `cb_extra` contains the callback arguments after the code object.
+fn fire(
+    vm: &VirtualMachine,
+    event: u32,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    cb_extra: &[PyObjectRef],
+) -> PyResult<()> {
+    // Prevent recursive event firing
+    if FIRING.with(|f| f.get()) {
+        return Ok(());
+    }
+
+    let event_id = event.trailing_zeros() as usize;
+    let code_id = code.get_id();
+
+    // C_RETURN and C_RAISE are implicitly enabled when CALL is set.
+    let check_bit = if event & EVENT_C_RETURN_MASK != 0 {
+        event | EVENT_CALL
+    } else {
+        event
+    };
+
+    // Collect callbacks and snapshot the DISABLE sentinel under a single lock.
+    let (callbacks, disable_sentinel): (Vec<(usize, PyObjectRef)>, Option<PyObjectRef>) = {
+        let state = vm.state.monitoring.lock();
+        let mut cbs = Vec::new();
+        for tool in 0..TOOL_LIMIT {
+            let global = state.global_events[tool];
+            let local = state
+                .local_events
+                .get(&(tool, code_id))
+                .copied()
+                .unwrap_or(0);
+            if ((global | local) & check_bit) == 0 {
+                continue;
+            }
+            if state.disabled.contains(&(code_id, offset as usize, tool)) {
+                continue;
+            }
+            if let Some(cb) = state.callbacks.get(&(tool, event_id)) {
+                cbs.push((tool, cb.clone()));
+            }
+        }
+        (cbs, state.disable.clone())
+    };
+
+    if callbacks.is_empty() {
+        return Ok(());
+    }
+
+    let mut args_vec = Vec::with_capacity(1 + cb_extra.len());
+    args_vec.push(code.clone().into());
+    args_vec.extend_from_slice(cb_extra);
+    let args = FuncArgs::from(args_vec);
+
+    FIRING.with(|f| f.set(true));
+    let result = (|| {
+        for (tool, cb) in callbacks {
+            let result = cb.call(args.clone(), vm)?;
+            if disable_sentinel.as_ref().is_some_and(|d| result.is(d)) {
+                // Only local events (event_id < LOCAL_EVENTS_COUNT) can be disabled.
+                // Non-local events (RAISE, EXCEPTION_HANDLED, PY_UNWIND, etc.)
+                // cannot be disabled per code object.
+                if event_id >= LOCAL_EVENTS_COUNT {
+                    // Remove the callback, matching CPython behavior.
+                    let mut state = vm.state.monitoring.lock();
+                    state.callbacks.remove(&(tool, event_id));
+                    return Err(vm.new_value_error(format!(
+                        "Cannot disable {} events. Callback removed.",
+                        EVENT_NAMES[event_id]
+                    )));
+                }
+                let mut state = vm.state.monitoring.lock();
+                state.disabled.insert((code_id, offset as usize, tool));
+            }
+        }
+        Ok(())
+    })();
+    FIRING.with(|f| f.set(false));
+    result
+}
+
+// Public dispatch functions (called from frame.rs)
+
+pub fn fire_py_start(vm: &VirtualMachine, code: &PyRef<PyCode>, offset: u32) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_START,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into()],
+    )
+}
+
+pub fn fire_py_resume(vm: &VirtualMachine, code: &PyRef<PyCode>, offset: u32) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_RESUME,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into()],
+    )
+}
+
+pub fn fire_py_return(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    retval: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_RETURN,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), retval.clone()],
+    )
+}
+
+pub fn fire_py_yield(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    retval: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_YIELD,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), retval.clone()],
+    )
+}
+
+pub fn fire_call(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    callable: &PyObjectRef,
+    arg0: PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_CALL,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), callable.clone(), arg0],
+    )
+}
+
+pub fn fire_c_return(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    callable: &PyObjectRef,
+    arg0: PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_C_RETURN,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), callable.clone(), arg0],
+    )
+}
+
+pub fn fire_c_raise(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    callable: &PyObjectRef,
+    arg0: PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_C_RAISE,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), callable.clone(), arg0],
+    )
+}
+
+pub fn fire_line(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    line: u32,
+) -> PyResult<()> {
+    fire(vm, EVENT_LINE, code, offset, &[vm.ctx.new_int(line).into()])
+}
+
+pub fn fire_instruction(vm: &VirtualMachine, code: &PyRef<PyCode>, offset: u32) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_INSTRUCTION,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into()],
+    )
+}
+
+pub fn fire_raise(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_RAISE,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+/// Only fires if no RERAISE has been fired since the last EXCEPTION_HANDLED,
+/// preventing duplicate events from chained cleanup handlers.
+pub fn fire_reraise(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    if RERAISE_PENDING.with(|f| f.get()) {
+        return Ok(());
+    }
+    RERAISE_PENDING.with(|f| f.set(true));
+    let result = fire(
+        vm,
+        EVENT_RERAISE,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    );
+    if result.is_err() {
+        RERAISE_PENDING.with(|f| f.set(false));
+    }
+    result
+}
+
+pub fn fire_exception_handled(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    RERAISE_PENDING.with(|f| f.set(false));
+    fire(
+        vm,
+        EVENT_EXCEPTION_HANDLED,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_py_unwind(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    RERAISE_PENDING.with(|f| f.set(false));
+    fire(
+        vm,
+        EVENT_PY_UNWIND,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_py_throw(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_PY_THROW,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_stop_iteration(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    exception: &PyObjectRef,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_STOP_ITERATION,
+        code,
+        offset,
+        &[vm.ctx.new_int(offset).into(), exception.clone()],
+    )
+}
+
+pub fn fire_jump(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    destination: u32,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_JUMP,
+        code,
+        offset,
+        &[
+            vm.ctx.new_int(offset).into(),
+            vm.ctx.new_int(destination).into(),
+        ],
+    )
+}
+
+pub fn fire_branch_left(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    destination: u32,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_BRANCH_LEFT,
+        code,
+        offset,
+        &[
+            vm.ctx.new_int(offset).into(),
+            vm.ctx.new_int(destination).into(),
+        ],
+    )
+}
+
+pub fn fire_branch_right(
+    vm: &VirtualMachine,
+    code: &PyRef<PyCode>,
+    offset: u32,
+    destination: u32,
+) -> PyResult<()> {
+    fire(
+        vm,
+        EVENT_BRANCH_RIGHT,
+        code,
+        offset,
+        &[
+            vm.ctx.new_int(offset).into(),
+            vm.ctx.new_int(destination).into(),
+        ],
+    )
+}
+
+#[pymodule(sub)]
+pub(super) mod sys_monitoring {
+    use super::*;
+
+    #[pyclass(no_attr, module = "sys.monitoring", name = "_Sentinel")]
+    #[derive(Debug, PyPayload)]
+    pub(super) struct MonitoringSentinel;
+
+    #[pyclass]
+    impl MonitoringSentinel {}
+
+    #[pyattr(name = "DEBUGGER_ID")]
+    const DEBUGGER_ID: u8 = 0;
+    #[pyattr(name = "COVERAGE_ID")]
+    const COVERAGE_ID: u8 = 1;
+    #[pyattr(name = "PROFILER_ID")]
+    const PROFILER_ID: u8 = 2;
+    #[pyattr(name = "OPTIMIZER_ID")]
+    const OPTIMIZER_ID: u8 = 5;
+
+    #[pyattr(once, name = "DISABLE")]
+    fn disable(vm: &VirtualMachine) -> PyObjectRef {
+        super::get_disable(vm)
+    }
+
+    #[pyattr(once, name = "MISSING")]
+    fn missing(vm: &VirtualMachine) -> PyObjectRef {
+        super::get_missing(vm)
+    }
+
+    #[pyattr(once)]
+    fn events(vm: &VirtualMachine) -> PyRef<PyNamespace> {
+        let events = PyNamespace::default().into_ref(&vm.ctx);
+        for (event_id, event_name) in EVENT_NAMES.iter().enumerate() {
+            events
+                .as_object()
+                .set_attr(*event_name, vm.ctx.new_int(1u32 << event_id), vm)
+                .expect("setting sys.monitoring.events attribute should not fail");
+        }
+        events
+            .as_object()
+            .set_attr("NO_EVENTS", vm.ctx.new_int(0), vm)
+            .expect("setting sys.monitoring.events.NO_EVENTS should not fail");
+        events
+    }
+
+    #[pyfunction]
+    fn use_tool_id(tool_id: i32, name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<()> {
+        super::use_tool_id(tool_id, name.as_str(), vm)
+    }
+
+    #[pyfunction]
+    fn clear_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+        super::clear_tool_id(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn free_tool_id(tool_id: i32, vm: &VirtualMachine) -> PyResult<()> {
+        super::free_tool_id(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn get_tool(tool_id: i32, vm: &VirtualMachine) -> PyResult<Option<String>> {
+        super::get_tool(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn register_callback(
+        tool_id: i32,
+        event: i32,
+        func: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        super::register_callback(tool_id, event, func, vm)
+    }
+
+    #[pyfunction]
+    fn get_events(tool_id: i32, vm: &VirtualMachine) -> PyResult<u32> {
+        super::get_events(tool_id, vm)
+    }
+
+    #[pyfunction]
+    fn set_events(tool_id: i32, event_set: i32, vm: &VirtualMachine) -> PyResult<()> {
+        super::set_events(tool_id, event_set, vm)
+    }
+
+    #[pyfunction]
+    fn get_local_events(tool_id: i32, code: PyObjectRef, vm: &VirtualMachine) -> PyResult<u32> {
+        super::get_local_events(tool_id, code, vm)
+    }
+
+    #[pyfunction]
+    fn set_local_events(
+        tool_id: i32,
+        code: PyObjectRef,
+        event_set: i32,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        super::set_local_events(tool_id, code, event_set, vm)
+    }
+
+    #[pyfunction]
+    fn restart_events(vm: &VirtualMachine) {
+        super::restart_events(vm)
+    }
+
+    #[pyfunction]
+    fn _all_events(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        super::all_events(vm)
+    }
+}
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
index 84eaa817ac4..d5ce93bd195 100644
--- a/crates/vm/src/types/slot.rs
+++ b/crates/vm/src/types/slot.rs
@@ -812,6 +812,8 @@ impl PyType {
                     }) {
                         self.slots.getattro.store(Some(func));
                     } else {
+                        // __getattribute__ is a Python method somewhere in MRO;
+                        // use the wrapper to dispatch through it.
                         self.slots.getattro.store(Some(getattro_wrapper));
                     }
                 } else {
diff --git a/crates/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
index f6d3ee4bc0a..2a664e39f9c 100644
--- a/crates/vm/src/vm/interpreter.rs
+++ b/crates/vm/src/vm/interpreter.rs
@@ -46,7 +46,7 @@ where
     use crate::common::hash::HashSecret;
     use crate::common::lock::PyMutex;
     use crate::warn::WarningsState;
-    use core::sync::atomic::AtomicBool;
+    use core::sync::atomic::{AtomicBool, AtomicU64};
     use crossbeam_utils::atomic::AtomicCell;
 
     let paths = getpath::init_path_config(&settings);
@@ -124,6 +124,9 @@ where
         thread_handles: parking_lot::Mutex::new(Vec::new()),
         #[cfg(feature = "threading")]
         shutdown_handles: parking_lot::Mutex::new(Vec::new()),
+        monitoring: PyMutex::default(),
+        monitoring_events: AtomicCell::new(0),
+        instrumentation_version: AtomicU64::new(0),
     });
 
     // Create VM with the global state
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
index 9802832ceab..ead41170229 100644
--- a/crates/vm/src/vm/mod.rs
+++ b/crates/vm/src/vm/mod.rs
@@ -43,7 +43,7 @@ use alloc::{borrow::Cow, collections::BTreeMap};
 use core::{
     cell::{Cell, OnceCell, RefCell},
     ptr::NonNull,
-    sync::atomic::{AtomicBool, Ordering},
+    sync::atomic::{AtomicBool, AtomicU64, Ordering},
 };
 use crossbeam_utils::atomic::AtomicCell;
 #[cfg(unix)]
@@ -155,6 +155,13 @@ pub struct PyGlobalState {
     /// Registry for non-daemon threads that need to be joined at shutdown
     #[cfg(feature = "threading")]
     pub shutdown_handles: parking_lot::Mutex<Vec<stdlib::thread::ShutdownEntry>>,
+    /// sys.monitoring state (tool names, events, callbacks)
+    pub monitoring: PyMutex<stdlib::sys::monitoring::MonitoringState>,
+    /// Fast-path mask: OR of all tools' events. 0 means no monitoring overhead.
+    pub monitoring_events: stdlib::sys::monitoring::MonitoringEventsMask,
+    /// Incremented on every monitoring state change. Code objects compare their
+    /// local version against this to decide whether re-instrumentation is needed.
+    pub instrumentation_version: AtomicU64,
 }
 
 pub fn process_hash_secret_seed() -> u32 {
diff --git a/scripts/update_lib/deps.py b/scripts/update_lib/deps.py
index cc169f2ff7a..46c08a8110e 100644
--- a/scripts/update_lib/deps.py
+++ b/scripts/update_lib/deps.py
@@ -823,6 +823,10 @@ def resolve_test_to_lib(test_name: str) -> str | None:
     "test_makefile": {
         "data": ["wheeldata"],
     },
+    # profilee is used by test_monitoring
+    "test_monitoring": {
+        "hard_deps": ["profilee"],
+    },
 }