diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
index 2a0ad7e280a..d1482b8c8a6 100644
--- a/crates/compiler-core/src/bytecode.rs
+++ b/crates/compiler-core/src/bytecode.rs
@@ -549,161 +549,92 @@ pub type NameIdx = u32;
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum Instruction {
-    Nop,
-    /// Importing by name
-    ImportName {
-        idx: Arg<NameIdx>,
-    },
-    /// Importing without name
-    ImportNameless,
-    /// from ... import ...
-    ImportFrom {
-        idx: Arg<NameIdx>,
-    },
-    LoadFast(Arg<NameIdx>),
-    LoadNameAny(Arg<NameIdx>),
-    LoadGlobal(Arg<NameIdx>),
-    LoadDeref(Arg<NameIdx>),
-    LoadClassDeref(Arg<NameIdx>),
-    StoreFast(Arg<NameIdx>),
-    StoreLocal(Arg<NameIdx>),
-    StoreGlobal(Arg<NameIdx>),
-    StoreDeref(Arg<NameIdx>),
-    DeleteFast(Arg<NameIdx>),
-    DeleteLocal(Arg<NameIdx>),
-    DeleteGlobal(Arg<NameIdx>),
-    DeleteDeref(Arg<NameIdx>),
-    LoadClosure(Arg<NameIdx>),
-    Subscript,
-    StoreSubscript,
-    DeleteSubscript,
-    /// Performs `is` comparison, or `is not` if `invert` is 1.
-    IsOp(Arg<Invert>),
-    /// Performs `in` comparison, or `not in` if `invert` is 1.
-    ContainsOp(Arg<Invert>),
-    StoreAttr {
-        idx: Arg<NameIdx>,
-    },
-    DeleteAttr {
-        idx: Arg<NameIdx>,
-    },
-    LoadConst {
-        /// index into constants vec
-        idx: Arg<u32>,
-    },
-    UnaryOperation {
-        op: Arg<UnaryOperator>,
-    },
+    BeforeAsyncWith,
     BinaryOp {
         op: Arg<BinaryOperator>,
     },
     BinarySubscript,
-    LoadAttr {
-        idx: Arg<NameIdx>,
-    },
-    CompareOperation {
-        op: Arg<ComparisonOperator>,
+    Break {
+        target: Arg<Label>,
     },
-    CopyItem {
-        index: Arg<u32>,
+    BuildListFromTuples {
+        size: Arg<u32>,
     },
-    Pop,
-    Swap {
-        index: Arg<u32>,
+    BuildList {
+        size: Arg<u32>,
     },
-    ToBool,
-    GetIter,
-    GetLen,
-    CallIntrinsic1 {
-        func: Arg<IntrinsicFunction1>,
+    BuildMapForCall {
+        size: Arg<u32>,
     },
-    CallIntrinsic2 {
-        func: Arg<IntrinsicFunction2>,
+    BuildMap {
+        size: Arg<u32>,
     },
-    Continue {
-        target: Arg<Label>,
+    BuildSetFromTuples {
+        size: Arg<u32>,
     },
-    Break {
-        target: Arg<Label>,
+    BuildSet {
+        size: Arg<u32>,
     },
-    /// Performs exception matching for except.
-    /// Tests whether the STACK[-2] is an exception matching STACK[-1].
-    /// Pops STACK[-1] and pushes the boolean result of the test.
-    JumpIfNotExcMatch(Arg<Label>),
-    Jump {
-        target: Arg<Label>,
+    BuildSlice {
+        argc: Arg<BuildSliceArgCount>,
     },
-    /// Pop the top of the stack, and jump if this value is true.
-    PopJumpIfTrue {
-        target: Arg<Label>,
+    BuildString {
+        size: Arg<u32>,
     },
-    /// Pop the top of the stack, and jump if this value is false.
-    PopJumpIfFalse {
-        target: Arg<Label>,
+    BuildTupleFromIter,
+    BuildTupleFromTuples {
+        size: Arg<u32>,
     },
-    /// Peek at the top of the stack, and jump if this value is true.
-    /// Otherwise, pop top of stack.
-    JumpIfTrueOrPop {
-        target: Arg<Label>,
+    BuildTuple {
+        size: Arg<u32>,
     },
-    /// Peek at the top of the stack, and jump if this value is false.
-    /// Otherwise, pop top of stack.
-    JumpIfFalseOrPop {
-        target: Arg<Label>,
+    CallFunctionEx {
+        has_kwargs: Arg<bool>,
     },
-    MakeFunction,
-    SetFunctionAttribute {
-        attr: Arg<MakeFunctionFlags>,
+    CallFunctionKeyword {
+        nargs: Arg<u32>,
     },
     CallFunctionPositional {
         nargs: Arg<u32>,
     },
-    CallFunctionKeyword {
-        nargs: Arg<u32>,
+    CallIntrinsic1 {
+        func: Arg<IntrinsicFunction1>,
     },
-    CallFunctionEx {
-        has_kwargs: Arg<bool>,
+    CallIntrinsic2 {
+        func: Arg<IntrinsicFunction2>,
     },
-    LoadMethod {
-        idx: Arg<NameIdx>,
+    CallMethodEx {
+        has_kwargs: Arg<bool>,
     },
-    CallMethodPositional {
+    CallMethodKeyword {
         nargs: Arg<u32>,
     },
-    CallMethodKeyword {
+    CallMethodPositional {
         nargs: Arg<u32>,
     },
-    CallMethodEx {
-        has_kwargs: Arg<bool>,
+    CompareOperation {
+        op: Arg<ComparisonOperator>,
     },
-    ForIter {
+    /// Performs `in` comparison, or `not in` if `invert` is 1.
+    ContainsOp(Arg<Invert>),
+    Continue {
         target: Arg<Label>,
     },
-    ReturnValue,
-    ReturnConst {
-        idx: Arg<u32>,
+    CopyItem {
+        index: Arg<u32>,
     },
-    YieldValue,
-    YieldFrom,
-
-    /// Resume execution (e.g., at function start, after yield, etc.)
-    Resume {
-        arg: Arg<u32>,
+    DeleteAttr {
+        idx: Arg<NameIdx>,
     },
-
-    SetupAnnotation,
-    SetupLoop,
-
-    /// Setup a finally handler, which will be called whenever one of this events occurs:
-    /// - the block is popped
-    /// - the function returns
-    /// - an exception is returned
-    SetupFinally {
-        handler: Arg<Label>,
+    DeleteDeref(Arg<NameIdx>),
+    DeleteFast(Arg<NameIdx>),
+    DeleteGlobal(Arg<NameIdx>),
+    DeleteLocal(Arg<NameIdx>),
+    DeleteSubscript,
+    DictUpdate {
+        index: Arg<u32>,
     },
-
-    /// Enter a finally block, without returning, excepting, just because we are there.
-    EnterFinally,
+    EndAsyncFor,
 
     /// Marker bytecode for the end of a finally sequence.
     /// When this bytecode is executed, the eval loop does one of those things:
@@ -713,95 +644,164 @@ pub enum Instruction {
     /// - Do nothing at all, just continue
     EndFinally,
 
-    SetupExcept {
-        handler: Arg<Label>,
+    /// Enter a finally block, without returning, excepting, just because we are there.
+    EnterFinally,
+    ExtendedArg,
+    ForIter {
+        target: Arg<Label>,
     },
-    SetupWith {
-        end: Arg<Label>,
+    FormatValue {
+        conversion: Arg<ConversionFlag>,
     },
-    WithCleanupStart,
-    WithCleanupFinish,
-    PopBlock,
-    Raise {
-        kind: Arg<RaiseKind>,
+    GetAIter,
+    GetANext,
+    GetAwaitable,
+    GetIter,
+    GetLen,
+    /// from ... import ...
+    ImportFrom {
+        idx: Arg<NameIdx>,
     },
-    BuildString {
-        size: Arg<u32>,
+    /// Importing without name
+    ImportNameless,
+    /// Importing by name
+    ImportName {
+        idx: Arg<NameIdx>,
     },
-    BuildTuple {
-        size: Arg<u32>,
+    /// Performs `is` comparison, or `is not` if `invert` is 1.
+    IsOp(Arg<Invert>),
+    /// Peek at the top of the stack, and jump if this value is false.
+    /// Otherwise, pop top of stack.
+    JumpIfFalseOrPop {
+        target: Arg<Label>,
     },
-    BuildTupleFromTuples {
-        size: Arg<u32>,
+    /// Performs exception matching for except.
+    /// Tests whether the STACK[-2] is an exception matching STACK[-1].
+    /// Pops STACK[-1] and pushes the boolean result of the test.
+    JumpIfNotExcMatch(Arg<Label>),
+    /// Peek at the top of the stack, and jump if this value is true.
+    /// Otherwise, pop top of stack.
+    JumpIfTrueOrPop {
+        target: Arg<Label>,
     },
-    BuildTupleFromIter,
-    BuildList {
-        size: Arg<u32>,
+    Jump {
+        target: Arg<Label>,
     },
-    BuildListFromTuples {
-        size: Arg<u32>,
+    ListAppend {
+        i: Arg<u32>,
     },
-    BuildSet {
-        size: Arg<u32>,
+    LoadAttr {
+        idx: Arg<NameIdx>,
     },
-    BuildSetFromTuples {
-        size: Arg<u32>,
+    LoadBuildClass,
+    LoadClassDeref(Arg<NameIdx>),
+    LoadClosure(Arg<NameIdx>),
+    LoadConst {
+        /// index into constants vec
+        idx: Arg<u32>,
     },
-    BuildMap {
-        size: Arg<u32>,
+    LoadDeref(Arg<NameIdx>),
+    LoadFast(Arg<NameIdx>),
+    LoadGlobal(Arg<NameIdx>),
+    LoadMethod {
+        idx: Arg<NameIdx>,
     },
-    BuildMapForCall {
-        size: Arg<u32>,
+    LoadNameAny(Arg<NameIdx>),
+    MakeFunction,
+    MapAdd {
+        i: Arg<u32>,
     },
-    DictUpdate {
-        index: Arg<u32>,
+    MatchClass(Arg<u32>),
+    MatchKeys,
+    MatchMapping,
+    MatchSequence,
+    Nop,
+    Pop,
+    PopBlock,
+    PopException,
+    /// Pop the top of the stack, and jump if this value is false.
+    PopJumpIfFalse {
+        target: Arg<Label>,
     },
-    BuildSlice {
-        argc: Arg<BuildSliceArgCount>,
+    /// Pop the top of the stack, and jump if this value is true.
+    PopJumpIfTrue {
+        target: Arg<Label>,
     },
-    ListAppend {
-        i: Arg<u32>,
+
+    PrintExpr,
+    Raise {
+        kind: Arg<RaiseKind>,
+    },
+
+    /// Resume execution (e.g., at function start, after yield, etc.)
+    Resume {
+        arg: Arg<u32>,
+    },
+    ReturnConst {
+        idx: Arg<u32>,
+    },
+    ReturnValue,
+    Reverse {
+        amount: Arg<u32>,
     },
     SetAdd {
         i: Arg<u32>,
     },
-    MapAdd {
-        i: Arg<u32>,
+    SetFunctionAttribute {
+        attr: Arg<MakeFunctionFlags>,
     },
 
-    PrintExpr,
-    LoadBuildClass,
-    UnpackSequence {
-        size: Arg<u32>,
-    },
-    UnpackEx {
-        args: Arg<UnpackExArgs>,
+    SetupAnnotation,
+    SetupAsyncWith {
+        end: Arg<Label>,
     },
-    FormatValue {
-        conversion: Arg<ConversionFlag>,
+
+    SetupExcept {
+        handler: Arg<Label>,
     },
-    PopException,
-    Reverse {
-        amount: Arg<u32>,
+
+    /// Setup a finally handler, which will be called whenever one of this events occurs:
+    /// - the block is popped
+    /// - the function returns
+    /// - an exception is returned
+    SetupFinally {
+        handler: Arg<Label>,
     },
-    GetAwaitable,
-    BeforeAsyncWith,
-    SetupAsyncWith {
+    SetupLoop,
+    SetupWith {
         end: Arg<Label>,
     },
-    GetAIter,
-    GetANext,
-    EndAsyncFor,
-    MatchMapping,
-    MatchSequence,
-    MatchKeys,
-    MatchClass(Arg<u32>),
-    ExtendedArg,
+    StoreAttr {
+        idx: Arg<NameIdx>,
+    },
+    StoreDeref(Arg<NameIdx>),
+    StoreFast(Arg<NameIdx>),
+    StoreGlobal(Arg<NameIdx>),
+    StoreLocal(Arg<NameIdx>),
+    StoreSubscript,
+    Subscript,
+    Swap {
+        index: Arg<u32>,
+    },
+    ToBool,
+    UnaryOperation {
+        op: Arg<UnaryOperator>,
+    },
+    UnpackEx {
+        args: Arg<UnpackExArgs>,
+    },
+    UnpackSequence {
+        size: Arg<u32>,
+    },
+    WithCleanupFinish,
+    WithCleanupStart,
+    YieldFrom,
+    YieldValue,
     // If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated
 }
 
 // This must be kept up to date to avoid marshaling errors
-const LAST_INSTRUCTION: Instruction = Instruction::ExtendedArg;
+const LAST_INSTRUCTION: Instruction = Instruction::YieldValue;
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
 
@@ -1798,114 +1798,112 @@ impl Instruction {
             };
 
         match self {
-            Nop => w!(Nop),
-            ImportName { idx } => w!(ImportName, name = idx),
-            ImportNameless => w!(ImportNameless),
-            ImportFrom { idx } => w!(ImportFrom, name = idx),
-            LoadFast(idx) => w!(LoadFast, varname = idx),
-            LoadNameAny(idx) => w!(LoadNameAny, name = idx),
-            LoadGlobal(idx) => w!(LoadGlobal, name = idx),
-            LoadDeref(idx) => w!(LoadDeref, cell_name = idx),
-            LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
-            StoreFast(idx) => w!(StoreFast, varname = idx),
-            StoreLocal(idx) => w!(StoreLocal, name = idx),
-            StoreGlobal(idx) => w!(StoreGlobal, name = idx),
-            StoreDeref(idx) => w!(StoreDeref, cell_name = idx),
-            DeleteFast(idx) => w!(DeleteFast, varname = idx),
-            DeleteLocal(idx) => w!(DeleteLocal, name = idx),
-            DeleteGlobal(idx) => w!(DeleteGlobal, name = idx),
-            DeleteDeref(idx) => w!(DeleteDeref, cell_name = idx),
-            LoadClosure(i) => w!(LoadClosure, cell_name = i),
-            IsOp(inv) => w!(IS_OP, ?inv),
-            ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
-            JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
-            Subscript => w!(Subscript),
-            StoreSubscript => w!(StoreSubscript),
-            DeleteSubscript => w!(DeleteSubscript),
-            StoreAttr { idx } => w!(StoreAttr, name = idx),
-            DeleteAttr { idx } => w!(DeleteAttr, name = idx),
-            LoadConst { idx } => fmt_const("LoadConst", arg, f, idx),
-            UnaryOperation { op } => w!(UnaryOperation, ?op),
+            BeforeAsyncWith => w!(BeforeAsyncWith),
             BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
-
             BinarySubscript => w!(BinarySubscript),
-            LoadAttr { idx } => w!(LoadAttr, name = idx),
+            Break { target } => w!(Break, target),
+            BuildListFromTuples { size } => w!(BuildListFromTuples, size),
+            BuildList { size } => w!(BuildList, size),
+            BuildMapForCall { size } => w!(BuildMapForCall, size),
+            BuildMap { size } => w!(BuildMap, size),
+            BuildSetFromTuples { size } => w!(BuildSetFromTuples, size),
+            BuildSet { size } => w!(BuildSet, size),
+            BuildSlice { argc } => w!(BuildSlice, ?argc),
+            BuildString { size } => w!(BuildString, size),
+            BuildTupleFromIter => w!(BuildTupleFromIter),
+            BuildTupleFromTuples { size } => w!(BuildTupleFromTuples, size),
+            BuildTuple { size } => w!(BuildTuple, size),
+            CallFunctionEx { has_kwargs } => w!(CallFunctionEx, has_kwargs),
+            CallFunctionKeyword { nargs } => w!(CallFunctionKeyword, nargs),
+            CallFunctionPositional { nargs } => w!(CallFunctionPositional, nargs),
+            CallIntrinsic1 { func } => w!(CallIntrinsic1, ?func),
+            CallIntrinsic2 { func } => w!(CallIntrinsic2, ?func),
+            CallMethodEx { has_kwargs } => w!(CallMethodEx, has_kwargs),
+            CallMethodKeyword { nargs } => w!(CallMethodKeyword, nargs),
+            CallMethodPositional { nargs } => w!(CallMethodPositional, nargs),
             CompareOperation { op } => w!(CompareOperation, ?op),
+            ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
+            Continue { target } => w!(Continue, target),
             CopyItem { index } => w!(CopyItem, index),
-            Pop => w!(Pop),
-            Swap { index } => w!(Swap, index),
-            ToBool => w!(ToBool),
+            DeleteAttr { idx } => w!(DeleteAttr, name = idx),
+            DeleteDeref(idx) => w!(DeleteDeref, cell_name = idx),
+            DeleteFast(idx) => w!(DeleteFast, varname = idx),
+            DeleteGlobal(idx) => w!(DeleteGlobal, name = idx),
+            DeleteLocal(idx) => w!(DeleteLocal, name = idx),
+            DeleteSubscript => w!(DeleteSubscript),
+            DictUpdate { index } => w!(DictUpdate, index),
+            EndAsyncFor => w!(EndAsyncFor),
+            EndFinally => w!(EndFinally),
+            EnterFinally => w!(EnterFinally),
+            ExtendedArg => w!(ExtendedArg, Arg::<u32>::marker()),
+            ForIter { target } => w!(ForIter, target),
+            FormatValue { conversion } => w!(FormatValue, ?conversion),
+            GetAIter => w!(GetAIter),
+            GetANext => w!(GetANext),
+            GetAwaitable => w!(GetAwaitable),
             GetIter => w!(GetIter),
-            // GET_LEN
             GetLen => w!(GetLen),
-            CallIntrinsic1 { func } => w!(CallIntrinsic1, ?func),
-            CallIntrinsic2 { func } => w!(CallIntrinsic2, ?func),
-            Continue { target } => w!(Continue, target),
-            Break { target } => w!(Break, target),
-            Jump { target } => w!(Jump, target),
-            PopJumpIfTrue { target } => w!(PopJumpIfTrue, target),
-            PopJumpIfFalse { target } => w!(PopJumpIfFalse, target),
-            JumpIfTrueOrPop { target } => w!(JumpIfTrueOrPop, target),
+            ImportFrom { idx } => w!(ImportFrom, name = idx),
+            ImportNameless => w!(ImportNameless),
+            ImportName { idx } => w!(ImportName, name = idx),
+            IsOp(inv) => w!(IS_OP, ?inv),
             JumpIfFalseOrPop { target } => w!(JumpIfFalseOrPop, target),
-            MakeFunction => w!(MakeFunction),
-            SetFunctionAttribute { attr } => w!(SetFunctionAttribute, ?attr),
-            CallFunctionPositional { nargs } => w!(CallFunctionPositional, nargs),
-            CallFunctionKeyword { nargs } => w!(CallFunctionKeyword, nargs),
-            CallFunctionEx { has_kwargs } => w!(CallFunctionEx, has_kwargs),
+            JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
+            JumpIfTrueOrPop { target } => w!(JumpIfTrueOrPop, target),
+            Jump { target } => w!(Jump, target),
+            ListAppend { i } => w!(ListAppend, i),
+            LoadAttr { idx } => w!(LoadAttr, name = idx),
+            LoadBuildClass => w!(LoadBuildClass),
+            LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
+            LoadClosure(i) => w!(LoadClosure, cell_name = i),
+            LoadConst { idx } => fmt_const("LoadConst", arg, f, idx),
+            LoadDeref(idx) => w!(LoadDeref, cell_name = idx),
+            LoadFast(idx) => w!(LoadFast, varname = idx),
+            LoadGlobal(idx) => w!(LoadGlobal, name = idx),
             LoadMethod { idx } => w!(LoadMethod, name = idx),
-            CallMethodPositional { nargs } => w!(CallMethodPositional, nargs),
-            CallMethodKeyword { nargs } => w!(CallMethodKeyword, nargs),
-            CallMethodEx { has_kwargs } => w!(CallMethodEx, has_kwargs),
-            ForIter { target } => w!(ForIter, target),
-            ReturnValue => w!(ReturnValue),
-            ReturnConst { idx } => fmt_const("ReturnConst", arg, f, idx),
+            LoadNameAny(idx) => w!(LoadNameAny, name = idx),
+            MakeFunction => w!(MakeFunction),
+            MapAdd { i } => w!(MapAdd, i),
+            MatchClass(arg) => w!(MatchClass, arg),
+            MatchKeys => w!(MatchKeys),
+            MatchMapping => w!(MatchMapping),
+            MatchSequence => w!(MatchSequence),
+            Nop => w!(Nop),
+            Pop => w!(Pop),
+            PopBlock => w!(PopBlock),
+            PopException => w!(PopException),
+            PopJumpIfFalse { target } => w!(PopJumpIfFalse, target),
+            PopJumpIfTrue { target } => w!(PopJumpIfTrue, target),
+            PrintExpr => w!(PrintExpr),
+            Raise { kind } => w!(Raise, ?kind),
             Resume { arg } => w!(Resume, arg),
-            YieldValue => w!(YieldValue),
-            YieldFrom => w!(YieldFrom),
+            ReturnConst { idx } => fmt_const("ReturnConst", arg, f, idx),
+            ReturnValue => w!(ReturnValue),
+            Reverse { amount } => w!(Reverse, amount),
+            SetAdd { i } => w!(SetAdd, i),
+            SetFunctionAttribute { attr } => w!(SetFunctionAttribute, ?attr),
             SetupAnnotation => w!(SetupAnnotation),
-            SetupLoop => w!(SetupLoop),
+            SetupAsyncWith { end } => w!(SetupAsyncWith, end),
             SetupExcept { handler } => w!(SetupExcept, handler),
             SetupFinally { handler } => w!(SetupFinally, handler),
-            EnterFinally => w!(EnterFinally),
-            EndFinally => w!(EndFinally),
+            SetupLoop => w!(SetupLoop),
             SetupWith { end } => w!(SetupWith, end),
-            WithCleanupStart => w!(WithCleanupStart),
-            WithCleanupFinish => w!(WithCleanupFinish),
-            BeforeAsyncWith => w!(BeforeAsyncWith),
-            SetupAsyncWith { end } => w!(SetupAsyncWith, end),
-            PopBlock => w!(PopBlock),
-            Raise { kind } => w!(Raise, ?kind),
-            BuildString { size } => w!(BuildString, size),
-            BuildTuple { size } => w!(BuildTuple, size),
-            BuildTupleFromTuples { size } => w!(BuildTupleFromTuples, size),
-            BuildTupleFromIter => w!(BuildTupleFromIter),
-            BuildList { size } => w!(BuildList, size),
-            BuildListFromTuples { size } => w!(BuildListFromTuples, size),
-            BuildSet { size } => w!(BuildSet, size),
-            BuildSetFromTuples { size } => w!(BuildSetFromTuples, size),
-            BuildMap { size } => w!(BuildMap, size),
-            BuildMapForCall { size } => w!(BuildMapForCall, size),
-            DictUpdate { index } => w!(DictUpdate, index),
-            BuildSlice { argc } => w!(BuildSlice, ?argc),
-            ListAppend { i } => w!(ListAppend, i),
-            SetAdd { i } => w!(SetAdd, i),
-            MapAdd { i } => w!(MapAdd, i),
-            PrintExpr => w!(PrintExpr),
-            LoadBuildClass => w!(LoadBuildClass),
-            UnpackSequence { size } => w!(UnpackSequence, size),
+            StoreAttr { idx } => w!(StoreAttr, name = idx),
+            StoreDeref(idx) => w!(StoreDeref, cell_name = idx),
+            StoreFast(idx) => w!(StoreFast, varname = idx),
+            StoreGlobal(idx) => w!(StoreGlobal, name = idx),
+            StoreLocal(idx) => w!(StoreLocal, name = idx),
+            StoreSubscript => w!(StoreSubscript),
+            Subscript => w!(Subscript),
+            Swap { index } => w!(Swap, index),
+            ToBool => w!(ToBool),
+            UnaryOperation { op } => w!(UnaryOperation, ?op),
             UnpackEx { args } => w!(UnpackEx, args),
-            FormatValue { conversion } => w!(FormatValue, ?conversion),
-            PopException => w!(PopException),
-            Reverse { amount } => w!(Reverse, amount),
-            GetAwaitable => w!(GetAwaitable),
-            GetAIter => w!(GetAIter),
-            GetANext => w!(GetANext),
-            EndAsyncFor => w!(EndAsyncFor),
-            MatchMapping => w!(MatchMapping),
-            MatchSequence => w!(MatchSequence),
-            MatchKeys => w!(MatchKeys),
-            MatchClass(arg) => w!(MatchClass, arg),
-            ExtendedArg => w!(ExtendedArg, Arg::<u32>::marker()),
+            UnpackSequence { size } => w!(UnpackSequence, size),
+            WithCleanupFinish => w!(WithCleanupFinish),
+            WithCleanupStart => w!(WithCleanupStart),
+            YieldFrom => w!(YieldFrom),
+            YieldValue => w!(YieldValue),
         }
     }
 }
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 8f25c757d19..9ada6c32781 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -275,167 +275,6 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         arg: OpArg,
     ) -> Result<(), JitCompileError> {
         match instruction {
-            Instruction::ExtendedArg => Ok(()),
-            Instruction::PopJumpIfFalse { target } => {
-                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                let val = self.boolean_val(cond)?;
-                let then_block = self.get_or_create_block(target.get(arg));
-                let else_block = self.builder.create_block();
-
-                self.builder
-                    .ins()
-                    .brif(val, else_block, &[], then_block, &[]);
-                self.builder.switch_to_block(else_block);
-
-                Ok(())
-            }
-            Instruction::PopJumpIfTrue { target } => {
-                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                let val = self.boolean_val(cond)?;
-                let then_block = self.get_or_create_block(target.get(arg));
-                let else_block = self.builder.create_block();
-
-                self.builder
-                    .ins()
-                    .brif(val, then_block, &[], else_block, &[]);
-                self.builder.switch_to_block(else_block);
-
-                Ok(())
-            }
-
-            Instruction::Jump { target } => {
-                let target_block = self.get_or_create_block(target.get(arg));
-                self.builder.ins().jump(target_block, &[]);
-                Ok(())
-            }
-            Instruction::LoadFast(idx) => {
-                let local = self.variables[idx.get(arg) as usize]
-                    .as_ref()
-                    .ok_or(JitCompileError::BadBytecode)?;
-                self.stack.push(JitValue::from_type_and_value(
-                    local.ty.clone(),
-                    self.builder.use_var(local.var),
-                ));
-                Ok(())
-            }
-            Instruction::StoreFast(idx) => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(idx.get(arg), val)
-            }
-            Instruction::LoadConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.stack.push(val);
-                Ok(())
-            }
-            Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize);
-                self.stack.push(JitValue::Tuple(elements));
-                Ok(())
-            }
-            Instruction::UnpackSequence { size } => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-
-                let elements = match val {
-                    JitValue::Tuple(elements) => elements,
-                    _ => return Err(JitCompileError::NotSupported),
-                };
-
-                if elements.len() != size.get(arg) as usize {
-                    return Err(JitCompileError::NotSupported);
-                }
-
-                self.stack.extend(elements.into_iter().rev());
-                Ok(())
-            }
-            Instruction::ReturnValue => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.return_value(val)
-            }
-            Instruction::ReturnConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.return_value(val)
-            }
-            Instruction::CompareOperation { op, .. } => {
-                let op = op.get(arg);
-                // the rhs is popped off first
-                let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-
-                let a_type: Option<JitType> = a.to_jit_type();
-                let b_type: Option<JitType> = b.to_jit_type();
-
-                match (a, b) {
-                    (JitValue::Int(a), JitValue::Int(b))
-                    | (JitValue::Bool(a), JitValue::Bool(b))
-                    | (JitValue::Bool(a), JitValue::Int(b))
-                    | (JitValue::Int(a), JitValue::Bool(b)) => {
-                        let operand_one = match a_type.unwrap() {
-                            JitType::Bool => self.builder.ins().uextend(types::I64, a),
-                            _ => a,
-                        };
-
-                        let operand_two = match b_type.unwrap() {
-                            JitType::Bool => self.builder.ins().uextend(types::I64, b),
-                            _ => b,
-                        };
-
-                        let cond = match op {
-                            ComparisonOperator::Equal => IntCC::Equal,
-                            ComparisonOperator::NotEqual => IntCC::NotEqual,
-                            ComparisonOperator::Less => IntCC::SignedLessThan,
-                            ComparisonOperator::LessOrEqual => IntCC::SignedLessThanOrEqual,
-                            ComparisonOperator::Greater => IntCC::SignedGreaterThan,
-                            ComparisonOperator::GreaterOrEqual => IntCC::SignedGreaterThanOrEqual,
-                        };
-
-                        let val = self.builder.ins().icmp(cond, operand_one, operand_two);
-                        self.stack.push(JitValue::Bool(val));
-                        Ok(())
-                    }
-                    (JitValue::Float(a), JitValue::Float(b)) => {
-                        let cond = match op {
-                            ComparisonOperator::Equal => FloatCC::Equal,
-                            ComparisonOperator::NotEqual => FloatCC::NotEqual,
-                            ComparisonOperator::Less => FloatCC::LessThan,
-                            ComparisonOperator::LessOrEqual => FloatCC::LessThanOrEqual,
-                            ComparisonOperator::Greater => FloatCC::GreaterThan,
-                            ComparisonOperator::GreaterOrEqual => FloatCC::GreaterThanOrEqual,
-                        };
-
-                        let val = self.builder.ins().fcmp(cond, a, b);
-                        self.stack.push(JitValue::Bool(val));
-                        Ok(())
-                    }
-                    _ => Err(JitCompileError::NotSupported),
-                }
-            }
-            Instruction::UnaryOperation { op, .. } => {
-                let op = op.get(arg);
-                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                match (op, a) {
-                    (UnaryOperator::Minus, JitValue::Int(val)) => {
-                        // Compile minus as 0 - a.
-                        let zero = self.builder.ins().iconst(types::I64, 0);
-                        let out = self.compile_sub(zero, val);
-                        self.stack.push(JitValue::Int(out));
-                        Ok(())
-                    }
-                    (UnaryOperator::Plus, JitValue::Int(val)) => {
-                        // Nothing to do
-                        self.stack.push(JitValue::Int(val));
-                        Ok(())
-                    }
-                    (UnaryOperator::Not, a) => {
-                        let boolean = self.boolean_val(a)?;
-                        let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
-                        self.stack.push(JitValue::Bool(not_boolean));
-                        Ok(())
-                    }
-                    _ => Err(JitCompileError::NotSupported),
-                }
-            }
             Instruction::BinaryOp { op } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
@@ -597,26 +436,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::SetupLoop => {
-                let loop_head = self.builder.create_block();
-                self.builder.ins().jump(loop_head, &[]);
-                self.builder.switch_to_block(loop_head);
-                Ok(())
-            }
-            Instruction::PopBlock => {
-                // TODO: block support
+            Instruction::BuildTuple { size } => {
+                let elements = self.pop_multiple(size.get(arg) as usize);
+                self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::LoadGlobal(idx) => {
-                let name = &bytecode.names[idx.get(arg) as usize];
-
-                if name.as_ref() != bytecode.obj_name.as_ref() {
-                    Err(JitCompileError::NotSupported)
-                } else {
-                    self.stack.push(JitValue::FuncRef(func_ref));
-                    Ok(())
-                }
-            }
             Instruction::CallFunctionPositional { nargs } => {
                 let nargs = nargs.get(arg);
 
@@ -637,7 +461,151 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
+            Instruction::CompareOperation { op, .. } => {
+                let op = op.get(arg);
+                // the rhs is popped off first
+                let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+
+                let a_type: Option<JitType> = a.to_jit_type();
+                let b_type: Option<JitType> = b.to_jit_type();
+
+                match (a, b) {
+                    (JitValue::Int(a), JitValue::Int(b))
+                    | (JitValue::Bool(a), JitValue::Bool(b))
+                    | (JitValue::Bool(a), JitValue::Int(b))
+                    | (JitValue::Int(a), JitValue::Bool(b)) => {
+                        let operand_one = match a_type.unwrap() {
+                            JitType::Bool => self.builder.ins().uextend(types::I64, a),
+                            _ => a,
+                        };
+
+                        let operand_two = match b_type.unwrap() {
+                            JitType::Bool => self.builder.ins().uextend(types::I64, b),
+                            _ => b,
+                        };
+
+                        let cond = match op {
+                            ComparisonOperator::Equal => IntCC::Equal,
+                            ComparisonOperator::NotEqual => IntCC::NotEqual,
+                            ComparisonOperator::Less => IntCC::SignedLessThan,
+                            ComparisonOperator::LessOrEqual => IntCC::SignedLessThanOrEqual,
+                            ComparisonOperator::Greater => IntCC::SignedGreaterThan,
+                            ComparisonOperator::GreaterOrEqual => IntCC::SignedGreaterThanOrEqual,
+                        };
+
+                        let val = self.builder.ins().icmp(cond, operand_one, operand_two);
+                        self.stack.push(JitValue::Bool(val));
+                        Ok(())
+                    }
+                    (JitValue::Float(a), JitValue::Float(b)) => {
+                        let cond = match op {
+                            ComparisonOperator::Equal => FloatCC::Equal,
+                            ComparisonOperator::NotEqual => FloatCC::NotEqual,
+                            ComparisonOperator::Less => FloatCC::LessThan,
+                            ComparisonOperator::LessOrEqual => FloatCC::LessThanOrEqual,
+                            ComparisonOperator::Greater => FloatCC::GreaterThan,
+                            ComparisonOperator::GreaterOrEqual => FloatCC::GreaterThanOrEqual,
+                        };
+
+                        let val = self.builder.ins().fcmp(cond, a, b);
+                        self.stack.push(JitValue::Bool(val));
+                        Ok(())
+                    }
+                    _ => Err(JitCompileError::NotSupported),
+                }
+            }
+            Instruction::ExtendedArg => Ok(()),
+
+            Instruction::Jump { target } => {
+                let target_block = self.get_or_create_block(target.get(arg));
+                self.builder.ins().jump(target_block, &[]);
+                Ok(())
+            }
+            Instruction::LoadConst { idx } => {
+                let val = self
+                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+                self.stack.push(val);
+                Ok(())
+            }
+            Instruction::LoadFast(idx) => {
+                let local = self.variables[idx.get(arg) as usize]
+                    .as_ref()
+                    .ok_or(JitCompileError::BadBytecode)?;
+                self.stack.push(JitValue::from_type_and_value(
+                    local.ty.clone(),
+                    self.builder.use_var(local.var),
+                ));
+                Ok(())
+            }
+            Instruction::LoadGlobal(idx) => {
+                let name = &bytecode.names[idx.get(arg) as usize];
+
+                if name.as_ref() != bytecode.obj_name.as_ref() {
+                    Err(JitCompileError::NotSupported)
+                } else {
+                    self.stack.push(JitValue::FuncRef(func_ref));
+                    Ok(())
+                }
+            }
             Instruction::Nop => Ok(()),
+            Instruction::Pop => {
+                self.stack.pop();
+                Ok(())
+            }
+            Instruction::PopBlock => {
+                // TODO: block support
+                Ok(())
+            }
+            Instruction::PopJumpIfFalse { target } => {
+                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                let val = self.boolean_val(cond)?;
+                let then_block = self.get_or_create_block(target.get(arg));
+                let else_block = self.builder.create_block();
+
+                self.builder
+                    .ins()
+                    .brif(val, else_block, &[], then_block, &[]);
+                self.builder.switch_to_block(else_block);
+
+                Ok(())
+            }
+            Instruction::PopJumpIfTrue { target } => {
+                let cond = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                let val = self.boolean_val(cond)?;
+                let then_block = self.get_or_create_block(target.get(arg));
+                let else_block = self.builder.create_block();
+
+                self.builder
+                    .ins()
+                    .brif(val, then_block, &[], else_block, &[]);
+                self.builder.switch_to_block(else_block);
+
+                Ok(())
+            }
+            Instruction::Resume { arg: _resume_arg } => {
+                // TODO: Implement the resume instruction
+                Ok(())
+            }
+            Instruction::ReturnConst { idx } => {
+                let val = self
+                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+                self.return_value(val)
+            }
+            Instruction::ReturnValue => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.return_value(val)
+            }
+            Instruction::SetupLoop => {
+                let loop_head = self.builder.create_block();
+                self.builder.ins().jump(loop_head, &[]);
+                self.builder.switch_to_block(loop_head);
+                Ok(())
+            }
+            Instruction::StoreFast(idx) => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.store_variable(idx.get(arg), val)
+            }
             Instruction::Swap { index } => {
                 let len = self.stack.len();
                 let i = len - 1;
@@ -645,12 +613,44 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.swap(i, j);
                 Ok(())
             }
-            Instruction::Pop => {
-                self.stack.pop();
-                Ok(())
+            Instruction::UnaryOperation { op, .. } => {
+                let op = op.get(arg);
+                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                match (op, a) {
+                    (UnaryOperator::Minus, JitValue::Int(val)) => {
+                        // Compile minus as 0 - a.
+                        let zero = self.builder.ins().iconst(types::I64, 0);
+                        let out = self.compile_sub(zero, val);
+                        self.stack.push(JitValue::Int(out));
+                        Ok(())
+                    }
+                    (UnaryOperator::Plus, JitValue::Int(val)) => {
+                        // Nothing to do
+                        self.stack.push(JitValue::Int(val));
+                        Ok(())
+                    }
+                    (UnaryOperator::Not, a) => {
+                        let boolean = self.boolean_val(a)?;
+                        let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
+                        self.stack.push(JitValue::Bool(not_boolean));
+                        Ok(())
+                    }
+                    _ => Err(JitCompileError::NotSupported),
+                }
             }
-            Instruction::Resume { arg: _resume_arg } => {
-                // TODO: Implement the resume instruction
+            Instruction::UnpackSequence { size } => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+
+                let elements = match val {
+                    JitValue::Tuple(elements) => elements,
+                    _ => return Err(JitCompileError::NotSupported),
+                };
+
+                if elements.len() != size.get(arg) as usize {
+                    return Err(JitCompileError::NotSupported);
+                }
+
+                self.stack.extend(elements.into_iter().rev());
                 Ok(())
             }
             _ => Err(JitCompileError::NotSupported),
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index bc684bc9f68..d6d5e42a21a 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -531,104 +531,202 @@ impl ExecutingFrame<'_> {
         }
 
         match instruction {
-            bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::LoadConst { idx } => {
-                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
+            bytecode::Instruction::BeforeAsyncWith => {
+                let mgr = self.pop_value();
+                let error_string = || -> String {
+                    format!(
+                        "'{:.200}' object does not support the asynchronous context manager protocol",
+                        mgr.class().name(),
+                    )
+                };
+
+                let aenter_res = vm
+                    .get_special_method(&mgr, identifier!(vm, __aenter__))?
+                    .ok_or_else(|| vm.new_type_error(error_string()))?
+                    .invoke((), vm)?;
+                let aexit = mgr
+                    .get_attr(identifier!(vm, __aexit__), vm)
+                    .map_err(|_exc| {
+                        vm.new_type_error({
+                            format!("{} (missed __aexit__ method)", error_string())
+                        })
+                    })?;
+                self.push_value(aexit);
+                self.push_value(aenter_res);
+
                 Ok(None)
             }
-            bytecode::Instruction::ImportName { idx } => {
-                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
+            bytecode::Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
+            bytecode::Instruction::BinarySubscript => {
+                let key = self.pop_value();
+                let container = self.pop_value();
+                self.state
+                    .stack
+                    .push(container.get_item(key.as_object(), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::ImportNameless => {
-                self.import(vm, None)?;
+
+            bytecode::Instruction::Break { target } => self.unwind_blocks(
+                vm,
+                UnwindReason::Break {
+                    target: target.get(arg),
+                },
+            ),
+            bytecode::Instruction::BuildListFromTuples { size } => {
+                // SAFETY: compiler guarantees `size` tuples are on the stack
+                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
+                let list_obj = vm.ctx.new_list(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::ImportFrom { idx } => {
-                let obj = self.import_from(vm, idx.get(arg))?;
-                self.push_value(obj);
+            bytecode::Instruction::BuildList { size } => {
+                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+                let list_obj = vm.ctx.new_list(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadFast(idx) => {
-                #[cold]
-                fn reference_error(
-                    varname: &'static PyStrInterned,
-                    vm: &VirtualMachine,
-                ) -> PyBaseExceptionRef {
-                    vm.new_exception_msg(
-                        vm.ctx.exceptions.unbound_local_error.to_owned(),
-                        format!("local variable '{varname}' referenced before assignment",),
-                    )
+            bytecode::Instruction::BuildMapForCall { size } => {
+                self.execute_build_map_for_call(vm, size.get(arg))
+            }
+            bytecode::Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
+            bytecode::Instruction::BuildSetFromTuples { size } => {
+                let set = PySet::default().into_ref(&vm.ctx);
+                for element in self.pop_multiple(size.get(arg) as usize) {
+                    // SAFETY: trust compiler
+                    let tup = unsafe { element.downcast_unchecked::<PyTuple>() };
+                    for item in tup.iter() {
+                        set.add(item.clone(), vm)?;
+                    }
                 }
-                let idx = idx.get(arg) as usize;
-                let x = self.fastlocals.lock()[idx]
-                    .clone()
-                    .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
-                self.push_value(x);
+                self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadNameAny(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
-                let result = self.locals.mapping().subscript(name, vm);
-                match result {
-                    Ok(x) => self.push_value(x),
-                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
-                        self.push_value(self.load_global_or_builtin(name, vm)?);
-                    }
-                    Err(e) => return Err(e),
+            bytecode::Instruction::BuildSet { size } => {
+                let set = PySet::default().into_ref(&vm.ctx);
+                for element in self.pop_multiple(size.get(arg) as usize) {
+                    set.add(element, vm)?;
                 }
+                self.push_value(set.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadGlobal(idx) => {
-                let name = &self.code.names[idx.get(arg) as usize];
-                let x = self.load_global_or_builtin(name, vm)?;
-                self.push_value(x);
+            bytecode::Instruction::BuildSlice { argc } => {
+                self.execute_build_slice(vm, argc.get(arg))
+            }
+            /*
+             bytecode::Instruction::ToBool => {
+                 dbg!("Shouldn't be called outside of match statements for now")
+                 let value = self.pop_value();
+                 // call __bool__
+                 let result = value.try_to_bool(vm)?;
+                 self.push_value(vm.ctx.new_bool(result).into());
+                 Ok(None)
+            }
+            */
+            bytecode::Instruction::BuildString { size } => {
+                let s = self
+                    .pop_multiple(size.get(arg) as usize)
+                    .as_slice()
+                    .iter()
+                    .map(|pyobj| pyobj.downcast_ref::<PyStr>().unwrap())
+                    .collect::<Wtf8Buf>();
+                let str_obj = vm.ctx.new_str(s);
+                self.push_value(str_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::LoadDeref(i) => {
-                let i = i.get(arg) as usize;
-                let x = self.cells_frees[i]
-                    .get()
-                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
-                self.push_value(x);
+            bytecode::Instruction::BuildTupleFromIter => {
+                if !self.top_value().class().is(vm.ctx.types.tuple_type) {
+                    let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
+                    let list_obj = vm.ctx.new_tuple(elements);
+                    self.push_value(list_obj.into());
+                }
                 Ok(None)
             }
-            bytecode::Instruction::LoadClassDeref(i) => {
-                let i = i.get(arg) as usize;
-                let name = if i < self.code.cellvars.len() {
-                    self.code.cellvars[i]
-                } else {
-                    self.code.freevars[i - self.code.cellvars.len()]
-                };
-                let value = self.locals.mapping().subscript(name, vm).ok();
-                self.push_value(match value {
-                    Some(v) => v,
-                    None => self.cells_frees[i]
-                        .get()
-                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?,
-                });
+            bytecode::Instruction::BuildTupleFromTuples { size } => {
+                // SAFETY: compiler guarantees `size` tuples are on the stack
+                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
+                let list_obj = vm.ctx.new_tuple(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::StoreFast(idx) => {
-                let value = self.pop_value();
-                self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
+            bytecode::Instruction::BuildTuple { size } => {
+                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+                let list_obj = vm.ctx.new_tuple(elements);
+                self.push_value(list_obj.into());
                 Ok(None)
             }
-            bytecode::Instruction::StoreLocal(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
+                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
+                self.execute_call(args, vm)
+            }
+            bytecode::Instruction::CallFunctionKeyword { nargs } => {
+                let args = self.collect_keyword_args(nargs.get(arg));
+                self.execute_call(args, vm)
+            }
+            bytecode::Instruction::CallFunctionPositional { nargs } => {
+                let args = self.collect_positional_args(nargs.get(arg));
+                self.execute_call(args, vm)
+            }
+            bytecode::Instruction::CallIntrinsic1 { func } => {
                 let value = self.pop_value();
-                self.locals.mapping().ass_subscript(name, Some(value), vm)?;
+                let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
+                self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::StoreGlobal(idx) => {
-                let value = self.pop_value();
-                self.globals
-                    .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
+            bytecode::Instruction::CallIntrinsic2 { func } => {
+                let value2 = self.pop_value();
+                let value1 = self.pop_value();
+                let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
+                self.push_value(result);
                 Ok(None)
             }
-            bytecode::Instruction::StoreDeref(i) => {
-                let value = self.pop_value();
-                self.cells_frees[i.get(arg) as usize].set(Some(value));
+            bytecode::Instruction::CallMethodEx { has_kwargs } => {
+                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
+                self.execute_method_call(args, vm)
+            }
+            bytecode::Instruction::CallMethodKeyword { nargs } => {
+                let args = self.collect_keyword_args(nargs.get(arg));
+                self.execute_method_call(args, vm)
+            }
+            bytecode::Instruction::CallMethodPositional { nargs } => {
+                let args = self.collect_positional_args(nargs.get(arg));
+                self.execute_method_call(args, vm)
+            }
+            bytecode::Instruction::CompareOperation { op } => self.execute_compare(vm, op.get(arg)),
+            bytecode::Instruction::ContainsOp(invert) => {
+                let b = self.pop_value();
+                let a = self.pop_value();
+
+                let value = match invert.get(arg) {
+                    bytecode::Invert::No => self._in(vm, &a, &b)?,
+                    bytecode::Invert::Yes => self._not_in(vm, &a, &b)?,
+                };
+                self.push_value(vm.ctx.new_bool(value).into());
+                Ok(None)
+            }
+            bytecode::Instruction::Continue { target } => self.unwind_blocks(
+                vm,
+                UnwindReason::Continue {
+                    target: target.get(arg),
+                },
+            ),
+            bytecode::Instruction::CopyItem { index } => {
+                // CopyItem { index: 1 } copies TOS
+                // CopyItem { index: 2 } copies second from top
+                // This is 1-indexed to match CPython
+                let idx = index.get(arg) as usize;
+                let value = self
+                    .state
+                    .stack
+                    .len()
+                    .checked_sub(idx)
+                    .map(|i| &self.state.stack[i])
+                    .unwrap();
+                self.push_value(value.clone());
+                Ok(None)
+            }
+            bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
+            bytecode::Instruction::DeleteDeref(i) => {
+                self.cells_frees[i.get(arg) as usize].set(None);
                 Ok(None)
             }
             bytecode::Instruction::DeleteFast(idx) => {
@@ -646,11 +744,9 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            bytecode::Instruction::DeleteLocal(idx) => {
+            bytecode::Instruction::DeleteGlobal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
-                let res = self.locals.mapping().ass_subscript(name, None, vm);
-
-                match res {
+                match self.globals.del_item(name, vm) {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
                         return Err(name_error(name, vm));
@@ -659,9 +755,11 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteGlobal(idx) => {
+            bytecode::Instruction::DeleteLocal(idx) => {
                 let name = self.code.names[idx.get(arg) as usize];
-                match self.globals.del_item(name, vm) {
+                let res = self.locals.mapping().ass_subscript(name, None, vm);
+
+                match res {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
                         return Err(name_error(name, vm));
@@ -670,134 +768,7 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            bytecode::Instruction::DeleteDeref(i) => {
-                self.cells_frees[i.get(arg) as usize].set(None);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadClosure(i) => {
-                let value = self.cells_frees[i.get(arg) as usize].clone();
-                self.push_value(value.into());
-                Ok(None)
-            }
-            bytecode::Instruction::Subscript => self.execute_subscript(vm),
-            bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
             bytecode::Instruction::DeleteSubscript => self.execute_delete_subscript(vm),
-            bytecode::Instruction::CopyItem { index } => {
-                // CopyItem { index: 1 } copies TOS
-                // CopyItem { index: 2 } copies second from top
-                // This is 1-indexed to match CPython
-                let idx = index.get(arg) as usize;
-                let value = self
-                    .state
-                    .stack
-                    .len()
-                    .checked_sub(idx)
-                    .map(|i| &self.state.stack[i])
-                    .unwrap();
-                self.push_value(value.clone());
-                Ok(None)
-            }
-            bytecode::Instruction::Pop => {
-                // Pop value from stack and ignore.
-                self.pop_value();
-                Ok(None)
-            }
-            bytecode::Instruction::Swap { index } => {
-                let len = self.state.stack.len();
-                debug_assert!(len > 0, "stack underflow in SWAP");
-                let i = len - 1; // TOS index
-                let index_val = index.get(arg) as usize;
-                // CPython: SWAP(n) swaps TOS with PEEK(n) where PEEK(n) = stack_pointer[-n]
-                // This means swap TOS with the element at index (len - n)
-                debug_assert!(
-                    index_val <= len,
-                    "SWAP index {} exceeds stack size {}",
-                    index_val,
-                    len
-                );
-                let j = len - index_val;
-                self.state.stack.swap(i, j);
-                Ok(None)
-            }
-            /*
-             bytecode::Instruction::ToBool => {
-                 dbg!("Shouldn't be called outside of match statements for now")
-                 let value = self.pop_value();
-                 // call __bool__
-                 let result = value.try_to_bool(vm)?;
-                 self.push_value(vm.ctx.new_bool(result).into());
-                 Ok(None)
-            }
-            */
-            bytecode::Instruction::BuildString { size } => {
-                let s = self
-                    .pop_multiple(size.get(arg) as usize)
-                    .as_slice()
-                    .iter()
-                    .map(|pyobj| pyobj.downcast_ref::<PyStr>().unwrap())
-                    .collect::<Wtf8Buf>();
-                let str_obj = vm.ctx.new_str(s);
-                self.push_value(str_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildList { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
-                let list_obj = vm.ctx.new_list(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildListFromTuples { size } => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_list(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildSet { size } => {
-                let set = PySet::default().into_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
-                    set.add(element, vm)?;
-                }
-                self.push_value(set.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildSetFromTuples { size } => {
-                let set = PySet::default().into_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
-                    // SAFETY: trust compiler
-                    let tup = unsafe { element.downcast_unchecked::<PyTuple>() };
-                    for item in tup.iter() {
-                        set.add(item.clone(), vm)?;
-                    }
-                }
-                self.push_value(set.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
-                let list_obj = vm.ctx.new_tuple(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTupleFromTuples { size } => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_tuple(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTupleFromIter => {
-                if !self.top_value().class().is(vm.ctx.types.tuple_type) {
-                    let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
-                    let list_obj = vm.ctx.new_tuple(elements);
-                    self.push_value(list_obj.into());
-                }
-                Ok(None)
-            }
-            bytecode::Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            bytecode::Instruction::BuildMapForCall { size } => {
-                self.execute_build_map_for_call(vm, size.get(arg))
-            }
             bytecode::Instruction::DictUpdate { index } => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
@@ -834,76 +805,163 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::BuildSlice { argc } => {
-                self.execute_build_slice(vm, argc.get(arg))
+            bytecode::Instruction::EndAsyncFor => {
+                let exc = self.pop_value();
+                let except_block = self.pop_block(); // pushed by TryExcept unwind
+                debug_assert_eq!(except_block.level, self.state.stack.len());
+                let _async_iterator = self.pop_value(); // __anext__ provider in the loop
+                if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) {
+                    vm.take_exception().expect("Should have exception in stack");
+                    Ok(None)
+                } else {
+                    Err(exc.downcast().unwrap())
+                }
             }
-            bytecode::Instruction::ListAppend { i } => {
-                let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let list: &Py<PyList> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                list.append(item);
-                Ok(None)
+            bytecode::Instruction::EndFinally => {
+                // Pop the finally handler from the stack, and recall
+                // what was the reason we were in this finally clause.
+                let block = self.pop_block();
+
+                if let BlockType::FinallyHandler { reason, prev_exc } = block.typ {
+                    vm.set_exception(prev_exc);
+                    if let Some(reason) = reason {
+                        self.unwind_blocks(vm, reason)
+                    } else {
+                        Ok(None)
+                    }
+                } else {
+                    self.fatal(
+                        "Block type must be finally handler when reaching EndFinally instruction!",
+                    );
+                }
             }
-            bytecode::Instruction::SetAdd { i } => {
-                let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let set: &Py<PySet> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                set.add(item, vm)?;
+            bytecode::Instruction::EnterFinally => {
+                self.push_block(BlockType::FinallyHandler {
+                    reason: None,
+                    prev_exc: vm.current_exception(),
+                });
                 Ok(None)
             }
-            bytecode::Instruction::MapAdd { i } => {
-                let value = self.pop_value();
-                let key = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let dict: &Py<PyDict> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                dict.set_item(&*key, value, vm)?;
+            bytecode::Instruction::ExtendedArg => {
+                *extend_arg = true;
                 Ok(None)
             }
-            bytecode::Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
-            bytecode::Instruction::BinarySubscript => {
-                let key = self.pop_value();
-                let container = self.pop_value();
-                self.state
-                    .stack
-                    .push(container.get_item(key.as_object(), vm)?);
+            bytecode::Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            bytecode::Instruction::FormatValue { conversion } => {
+                self.format_value(conversion.get(arg), vm)
+            }
+            bytecode::Instruction::GetAIter => {
+                let aiterable = self.pop_value();
+                let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
+                self.push_value(aiter);
                 Ok(None)
             }
-            bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            bytecode::Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            bytecode::Instruction::UnaryOperation { op } => self.execute_unary_op(vm, op.get(arg)),
-            bytecode::Instruction::IsOp(invert) => {
-                let b = self.pop_value();
-                let a = self.pop_value();
-                let res = a.is(&b);
+            bytecode::Instruction::GetANext => {
+                #[cfg(debug_assertions)] // remove when GetANext is fully implemented
+                let orig_stack_len = self.state.stack.len();
 
-                let value = match invert.get(arg) {
-                    bytecode::Invert::No => res,
-                    bytecode::Invert::Yes => !res,
+                let aiter = self.top_value();
+                let awaitable = if aiter.class().is(vm.ctx.types.async_generator) {
+                    vm.call_special_method(aiter, identifier!(vm, __anext__), ())?
+                } else {
+                    if !aiter.has_attr("__anext__", vm).unwrap_or(false) {
+                        // TODO: __anext__ must be protocol
+                        let msg = format!(
+                            "'async for' requires an iterator with __anext__ method, got {:.100}",
+                            aiter.class().name()
+                        );
+                        return Err(vm.new_type_error(msg));
+                    }
+                    let next_iter =
+                        vm.call_special_method(aiter, identifier!(vm, __anext__), ())?;
+
+                    // _PyCoro_GetAwaitableIter in CPython
+                    fn get_awaitable_iter(next_iter: &PyObject, vm: &VirtualMachine) -> PyResult {
+                        let gen_is_coroutine = |_| {
+                            // TODO: cpython gen_is_coroutine
+                            true
+                        };
+                        if next_iter.class().is(vm.ctx.types.coroutine_type)
+                            || gen_is_coroutine(next_iter)
+                        {
+                            return Ok(next_iter.to_owned());
+                        }
+                        // TODO: error handling
+                        vm.call_special_method(next_iter, identifier!(vm, __await__), ())
+                    }
+                    get_awaitable_iter(&next_iter, vm).map_err(|_| {
+                        vm.new_type_error(format!(
+                            "'async for' received an invalid object from __anext__: {:.200}",
+                            next_iter.class().name()
+                        ))
+                    })?
                 };
-                self.push_value(vm.ctx.new_bool(value).into());
+                self.push_value(awaitable);
+                #[cfg(debug_assertions)]
+                debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
                 Ok(None)
             }
-            bytecode::Instruction::ContainsOp(invert) => {
-                let b = self.pop_value();
+            bytecode::Instruction::GetAwaitable => {
+                let awaited_obj = self.pop_value();
+                let awaitable = if awaited_obj.downcastable::<PyCoroutine>() {
+                    awaited_obj
+                } else {
+                    let await_method = vm.get_method_or_type_error(
+                        awaited_obj.clone(),
+                        identifier!(vm, __await__),
+                        || {
+                            format!(
+                                "object {} can't be used in 'await' expression",
+                                awaited_obj.class().name(),
+                            )
+                        },
+                    )?;
+                    await_method.call((), vm)?
+                };
+                self.push_value(awaitable);
+                Ok(None)
+            }
+            bytecode::Instruction::GetIter => {
+                let iterated_obj = self.pop_value();
+                let iter_obj = iterated_obj.get_iter(vm)?;
+                self.push_value(iter_obj.into());
+                Ok(None)
+            }
+            bytecode::Instruction::GetLen => {
+                // STACK.append(len(STACK[-1]))
+                let obj = self.top_value();
+                let len = obj.length(vm)?;
+                self.push_value(vm.ctx.new_int(len).into());
+                Ok(None)
+            }
+            bytecode::Instruction::ImportFrom { idx } => {
+                let obj = self.import_from(vm, idx.get(arg))?;
+                self.push_value(obj);
+                Ok(None)
+            }
+            bytecode::Instruction::ImportNameless => {
+                self.import(vm, None)?;
+                Ok(None)
+            }
+            bytecode::Instruction::ImportName { idx } => {
+                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
+                Ok(None)
+            }
+            bytecode::Instruction::IsOp(invert) => {
+                let b = self.pop_value();
                 let a = self.pop_value();
+                let res = a.is(&b);
 
                 let value = match invert.get(arg) {
-                    bytecode::Invert::No => self._in(vm, &a, &b)?,
-                    bytecode::Invert::Yes => self._not_in(vm, &a, &b)?,
+                    bytecode::Invert::No => res,
+                    bytecode::Invert::Yes => !res,
                 };
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
+            bytecode::Instruction::JumpIfFalseOrPop { target } => {
+                self.jump_if_or_pop(vm, target.get(arg), false)
+            }
             bytecode::Instruction::JumpIfNotExcMatch(target) => {
                 let b = self.pop_value();
                 let a = self.pop_value();
@@ -927,619 +985,561 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::CompareOperation { op } => self.execute_compare(vm, op.get(arg)),
-            bytecode::Instruction::ReturnValue => {
-                let value = self.pop_value();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
+            bytecode::Instruction::JumpIfTrueOrPop { target } => {
+                self.jump_if_or_pop(vm, target.get(arg), true)
             }
-            bytecode::Instruction::ReturnConst { idx } => {
-                let value = self.code.constants[idx.get(arg) as usize].clone().into();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
+            bytecode::Instruction::Jump { target } => {
+                self.jump(target.get(arg));
+                Ok(None)
             }
-            bytecode::Instruction::YieldValue => {
-                let value = self.pop_value();
-                let value = if self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
-                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
-                } else {
-                    value
+            bytecode::Instruction::ListAppend { i } => {
+                let item = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let list: &Py<PyList> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
                 };
-                Ok(Some(ExecutionResult::Yield(value)))
-            }
-            bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
-            bytecode::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()?;
-                // }
+                list.append(item);
                 Ok(None)
             }
-            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
-            bytecode::Instruction::SetupLoop => {
-                self.push_block(BlockType::Loop);
+            bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
+            bytecode::Instruction::LoadBuildClass => {
+                self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
                 Ok(None)
             }
-            bytecode::Instruction::SetupExcept { handler } => {
-                self.push_block(BlockType::TryExcept {
-                    handler: handler.get(arg),
+            bytecode::Instruction::LoadClassDeref(i) => {
+                let i = i.get(arg) as usize;
+                let name = if i < self.code.cellvars.len() {
+                    self.code.cellvars[i]
+                } else {
+                    self.code.freevars[i - self.code.cellvars.len()]
+                };
+                let value = self.locals.mapping().subscript(name, vm).ok();
+                self.push_value(match value {
+                    Some(v) => v,
+                    None => self.cells_frees[i]
+                        .get()
+                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?,
                 });
                 Ok(None)
             }
-            bytecode::Instruction::SetupFinally { handler } => {
-                self.push_block(BlockType::Finally {
-                    handler: handler.get(arg),
-                });
+            bytecode::Instruction::LoadClosure(i) => {
+                let value = self.cells_frees[i.get(arg) as usize].clone();
+                self.push_value(value.into());
                 Ok(None)
             }
-            bytecode::Instruction::EnterFinally => {
-                self.push_block(BlockType::FinallyHandler {
-                    reason: None,
-                    prev_exc: vm.current_exception(),
-                });
+            bytecode::Instruction::LoadConst { idx } => {
+                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
                 Ok(None)
             }
-            bytecode::Instruction::EndFinally => {
-                // Pop the finally handler from the stack, and recall
-                // what was the reason we were in this finally clause.
-                let block = self.pop_block();
-
-                if let BlockType::FinallyHandler { reason, prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    if let Some(reason) = reason {
-                        self.unwind_blocks(vm, reason)
-                    } else {
-                        Ok(None)
-                    }
-                } else {
-                    self.fatal(
-                        "Block type must be finally handler when reaching EndFinally instruction!",
-                    );
-                }
+            bytecode::Instruction::LoadDeref(i) => {
+                let i = i.get(arg) as usize;
+                let x = self.cells_frees[i]
+                    .get()
+                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
+                self.push_value(x);
+                Ok(None)
             }
-            bytecode::Instruction::SetupWith { end } => {
-                let context_manager = self.pop_value();
-                let error_string = || -> String {
-                    format!(
-                        "'{:.200}' object does not support the context manager protocol",
-                        context_manager.class().name(),
+            bytecode::Instruction::LoadFast(idx) => {
+                #[cold]
+                fn reference_error(
+                    varname: &'static PyStrInterned,
+                    vm: &VirtualMachine,
+                ) -> PyBaseExceptionRef {
+                    vm.new_exception_msg(
+                        vm.ctx.exceptions.unbound_local_error.to_owned(),
+                        format!("local variable '{varname}' referenced before assignment",),
                     )
-                };
-                let enter_res = vm
-                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
-                    .ok_or_else(|| vm.new_type_error(error_string()))?
-                    .invoke((), vm)?;
-
-                let exit = context_manager
-                    .get_attr(identifier!(vm, __exit__), vm)
-                    .map_err(|_exc| {
-                        vm.new_type_error({
-                            format!("{} (missed __exit__ method)", error_string())
-                        })
-                    })?;
-                self.push_value(exit);
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
-                self.push_value(enter_res);
+                }
+                let idx = idx.get(arg) as usize;
+                let x = self.fastlocals.lock()[idx]
+                    .clone()
+                    .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
+                self.push_value(x);
                 Ok(None)
             }
-            bytecode::Instruction::BeforeAsyncWith => {
-                let mgr = self.pop_value();
-                let error_string = || -> String {
-                    format!(
-                        "'{:.200}' object does not support the asynchronous context manager protocol",
-                        mgr.class().name(),
-                    )
+            bytecode::Instruction::LoadGlobal(idx) => {
+                let name = &self.code.names[idx.get(arg) as usize];
+                let x = self.load_global_or_builtin(name, vm)?;
+                self.push_value(x);
+                Ok(None)
+            }
+            bytecode::Instruction::LoadMethod { idx } => {
+                let obj = self.pop_value();
+                let method_name = self.code.names[idx.get(arg) as usize];
+                let method = PyMethod::get(obj, method_name, vm)?;
+                let (target, is_method, func) = match method {
+                    PyMethod::Function { target, func } => (target, true, func),
+                    PyMethod::Attribute(val) => (vm.ctx.none(), false, val),
                 };
-
-                let aenter_res = vm
-                    .get_special_method(&mgr, identifier!(vm, __aenter__))?
-                    .ok_or_else(|| vm.new_type_error(error_string()))?
-                    .invoke((), vm)?;
-                let aexit = mgr
-                    .get_attr(identifier!(vm, __aexit__), vm)
-                    .map_err(|_exc| {
-                        vm.new_type_error({
-                            format!("{} (missed __aexit__ method)", error_string())
-                        })
-                    })?;
-                self.push_value(aexit);
-                self.push_value(aenter_res);
-
+                // TODO: figure out a better way to communicate PyMethod::Attribute - CPython uses
+                // target==NULL, maybe we could use a sentinel value or something?
+                self.push_value(target);
+                self.push_value(vm.ctx.new_bool(is_method).into());
+                self.push_value(func);
                 Ok(None)
             }
-            bytecode::Instruction::SetupAsyncWith { end } => {
-                let enter_res = self.pop_value();
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
-                self.push_value(enter_res);
+            bytecode::Instruction::LoadNameAny(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let result = self.locals.mapping().subscript(name, vm);
+                match result {
+                    Ok(x) => self.push_value(x),
+                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                        self.push_value(self.load_global_or_builtin(name, vm)?);
+                    }
+                    Err(e) => return Err(e),
+                }
                 Ok(None)
             }
-            bytecode::Instruction::WithCleanupStart => {
-                let block = self.current_block().unwrap();
-                let reason = match block.typ {
-                    BlockType::FinallyHandler { reason, .. } => reason,
-                    _ => self.fatal("WithCleanupStart expects a FinallyHandler block on stack"),
-                };
-                let exc = match reason {
-                    Some(UnwindReason::Raising { exception }) => Some(exception),
-                    _ => None,
+            bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
+            bytecode::Instruction::MapAdd { i } => {
+                let value = self.pop_value();
+                let key = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let dict: &Py<PyDict> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
                 };
+                dict.set_item(&*key, value, vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::MatchClass(nargs) => {
+                // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
+                // nargs is the number of positional sub-patterns.
+                let kwd_attrs = self.pop_value();
+                let kwd_attrs = kwd_attrs.downcast_ref::<PyTuple>().unwrap();
+                let cls = self.pop_value();
+                let subject = self.pop_value();
+                let nargs_val = nargs.get(arg) as usize;
 
-                let exit = self.top_value();
+                // Check if subject is an instance of cls
+                if subject.is_instance(cls.as_ref(), vm)? {
+                    let mut extracted = vec![];
 
-                let args = if let Some(exc) = exc {
-                    vm.split_exception(exc)
-                } else {
-                    (vm.ctx.none(), vm.ctx.none(), vm.ctx.none())
-                };
-                let exit_res = exit.call(args, vm)?;
-                self.replace_top(exit_res);
+                    // Get __match_args__ for positional arguments if nargs > 0
+                    if nargs_val > 0 {
+                        // Get __match_args__ from the class
+                        let match_args =
+                            vm.get_attribute_opt(cls.clone(), identifier!(vm, __match_args__))?;
+
+                        if let Some(match_args) = match_args {
+                            // Convert to tuple
+                            let match_args = match match_args.downcast_exact::<PyTuple>(vm) {
+                                Ok(tuple) => tuple,
+                                Err(match_args) => {
+                                    // __match_args__ must be a tuple
+                                    // Get type names for error message
+                                    let type_name = cls
+                                        .downcast::<crate::builtins::PyType>()
+                                        .map(|t| t.__name__(vm).as_str().to_owned())
+                                        .unwrap_or_else(|_| String::from("?"));
+                                    let match_args_type_name = match_args.class().__name__(vm);
+                                    return Err(vm.new_type_error(format!(
+                                        "{}.__match_args__ must be a tuple (got {})",
+                                        type_name, match_args_type_name
+                                    )));
+                                }
+                            };
+
+                            // Check if we have enough match args
+                            if match_args.len() < nargs_val {
+                                return Err(vm.new_type_error(format!(
+                                    "class pattern accepts at most {} positional sub-patterns ({} given)",
+                                    match_args.len(),
+                                    nargs_val
+                                )));
+                            }
+
+                            // Extract positional attributes
+                            for i in 0..nargs_val {
+                                let attr_name = &match_args[i];
+                                let attr_name_str = match attr_name.downcast_ref::<PyStr>() {
+                                    Some(s) => s,
+                                    None => {
+                                        return Err(vm.new_type_error(
+                                            "__match_args__ elements must be strings".to_string(),
+                                        ));
+                                    }
+                                };
+                                match subject.get_attr(attr_name_str, vm) {
+                                    Ok(value) => extracted.push(value),
+                                    Err(e)
+                                        if e.fast_isinstance(vm.ctx.exceptions.attribute_error) =>
+                                    {
+                                        // Missing attribute → non-match
+                                        self.push_value(vm.ctx.none());
+                                        return Ok(None);
+                                    }
+                                    Err(e) => return Err(e),
+                                }
+                            }
+                        } else {
+                            // No __match_args__, check if this is a type with MATCH_SELF behavior
+                            // For built-in types like bool, int, str, list, tuple, dict, etc.
+                            // they match the subject itself as the single positional argument
+                            let is_match_self_type = cls
+                                .downcast::<PyType>()
+                                .is_ok_and(|t| t.slots.flags.contains(PyTypeFlags::_MATCH_SELF));
+
+                            if is_match_self_type {
+                                if nargs_val == 1 {
+                                    // Match the subject itself as the single positional argument
+                                    extracted.push(subject.clone());
+                                } else if nargs_val > 1 {
+                                    // Too many positional arguments for MATCH_SELF
+                                    return Err(vm.new_type_error(
+                                        "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types"
+                                            .to_string(),
+                                    ));
+                                }
+                            } else {
+                                // No __match_args__ and not a MATCH_SELF type
+                                if nargs_val > 0 {
+                                    return Err(vm.new_type_error(
+                                        "class pattern defines no positional sub-patterns (__match_args__ missing)"
+                                            .to_string(),
+                                    ));
+                                }
+                            }
+                        }
+                    }
+
+                    // Extract keyword attributes
+                    for name in kwd_attrs {
+                        let name_str = name.downcast_ref::<PyStr>().unwrap();
+                        match subject.get_attr(name_str, vm) {
+                            Ok(value) => extracted.push(value),
+                            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => {
+                                self.push_value(vm.ctx.none());
+                                return Ok(None);
+                            }
+                            Err(e) => return Err(e),
+                        }
+                    }
 
+                    self.push_value(vm.ctx.new_tuple(extracted).into());
+                } else {
+                    // Not an instance, push None
+                    self.push_value(vm.ctx.none());
+                }
                 Ok(None)
             }
-            bytecode::Instruction::WithCleanupFinish => {
-                let block = self.pop_block();
-                let (reason, prev_exc) = match block.typ {
-                    BlockType::FinallyHandler { reason, prev_exc } => (reason, prev_exc),
-                    _ => self.fatal("WithCleanupFinish expects a FinallyHandler block on stack"),
-                };
+            bytecode::Instruction::MatchKeys => {
+                // MATCH_KEYS doesn't pop subject and keys, only reads them
+                let keys_tuple = self.top_value(); // stack[-1]
+                let subject = self.nth_value(1); // stack[-2]
 
-                vm.set_exception(prev_exc);
+                // Check if subject is a mapping and extract values for keys
+                if subject.class().slots.flags.contains(PyTypeFlags::MAPPING) {
+                    let keys = keys_tuple.downcast_ref::<PyTuple>().unwrap();
+                    let mut values = Vec::new();
+                    let mut all_match = true;
 
-                let suppress_exception = self.pop_value().try_to_bool(vm)?;
+                    // We use the two argument form of map.get(key, default) for two reasons:
+                    // - Atomically check for a key and get its value without error handling.
+                    // - Don't cause key creation or resizing in dict subclasses like
+                    //   collections.defaultdict that define __missing__ (or similar).
+                    // See CPython's _PyEval_MatchKeys
 
-                if suppress_exception {
-                    Ok(None)
-                } else if let Some(reason) = reason {
-                    self.unwind_blocks(vm, reason)
+                    if let Some(get_method) = vm
+                        .get_method(subject.to_owned(), vm.ctx.intern_str("get"))
+                        .transpose()?
+                    {
+                        // dummy = object()
+                        // CPython: dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);
+                        let dummy = vm
+                            .ctx
+                            .new_base_object(vm.ctx.types.object_type.to_owned(), None);
+
+                        for key in keys {
+                            // value = map.get(key, dummy)
+                            match get_method.call((key.as_object(), dummy.clone()), vm) {
+                                Ok(value) => {
+                                    // if value == dummy: key not in map!
+                                    if value.is(&dummy) {
+                                        all_match = false;
+                                        break;
+                                    }
+                                    values.push(value);
+                                }
+                                Err(e) => return Err(e),
+                            }
+                        }
+                    } else {
+                        // Fallback if .get() method is not available (shouldn't happen for mappings)
+                        for key in keys {
+                            match subject.get_item(key.as_object(), vm) {
+                                Ok(value) => values.push(value),
+                                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                                    all_match = false;
+                                    break;
+                                }
+                                Err(e) => return Err(e),
+                            }
+                        }
+                    }
+
+                    if all_match {
+                        // Push values tuple on successful match
+                        self.push_value(vm.ctx.new_tuple(values).into());
+                    } else {
+                        // No match - push None
+                        self.push_value(vm.ctx.none());
+                    }
                 } else {
-                    Ok(None)
+                    // Not a mapping - push None
+                    self.push_value(vm.ctx.none());
                 }
-            }
-            bytecode::Instruction::PopBlock => {
-                self.pop_block();
                 Ok(None)
             }
-            bytecode::Instruction::GetIter => {
-                let iterated_obj = self.pop_value();
-                let iter_obj = iterated_obj.get_iter(vm)?;
-                self.push_value(iter_obj.into());
+            bytecode::Instruction::MatchMapping => {
+                // Pop and push back the subject to keep it on stack
+                let subject = self.pop_value();
+
+                // Check if the type has the MAPPING flag
+                let is_mapping = subject.class().slots.flags.contains(PyTypeFlags::MAPPING);
+
+                self.push_value(subject);
+                self.push_value(vm.ctx.new_bool(is_mapping).into());
                 Ok(None)
             }
-            bytecode::Instruction::GetLen => {
-                // STACK.append(len(STACK[-1]))
-                let obj = self.top_value();
-                let len = obj.length(vm)?;
-                self.push_value(vm.ctx.new_int(len).into());
+            bytecode::Instruction::MatchSequence => {
+                // Pop and push back the subject to keep it on stack
+                let subject = self.pop_value();
+
+                // Check if the type has the SEQUENCE flag
+                let is_sequence = subject.class().slots.flags.contains(PyTypeFlags::SEQUENCE);
+
+                self.push_value(subject);
+                self.push_value(vm.ctx.new_bool(is_sequence).into());
                 Ok(None)
             }
-            bytecode::Instruction::ToBool => {
-                let obj = self.pop_value();
-                let bool_val = obj.try_to_bool(vm)?;
-                self.push_value(vm.ctx.new_bool(bool_val).into());
+            bytecode::Instruction::Nop => Ok(None),
+            bytecode::Instruction::Pop => {
+                // Pop value from stack and ignore.
+                self.pop_value();
                 Ok(None)
             }
-            bytecode::Instruction::CallIntrinsic1 { func } => {
-                let value = self.pop_value();
-                let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
-                self.push_value(result);
+            bytecode::Instruction::PopBlock => {
+                self.pop_block();
                 Ok(None)
             }
-            bytecode::Instruction::CallIntrinsic2 { func } => {
-                let value2 = self.pop_value();
-                let value1 = self.pop_value();
-                let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
-                self.push_value(result);
-                Ok(None)
-            }
-            bytecode::Instruction::GetAwaitable => {
-                let awaited_obj = self.pop_value();
-                let awaitable = if awaited_obj.downcastable::<PyCoroutine>() {
-                    awaited_obj
-                } else {
-                    let await_method = vm.get_method_or_type_error(
-                        awaited_obj.clone(),
-                        identifier!(vm, __await__),
-                        || {
-                            format!(
-                                "object {} can't be used in 'await' expression",
-                                awaited_obj.class().name(),
-                            )
-                        },
-                    )?;
-                    await_method.call((), vm)?
-                };
-                self.push_value(awaitable);
-                Ok(None)
-            }
-            bytecode::Instruction::GetAIter => {
-                let aiterable = self.pop_value();
-                let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
-                self.push_value(aiter);
-                Ok(None)
-            }
-            bytecode::Instruction::GetANext => {
-                #[cfg(debug_assertions)] // remove when GetANext is fully implemented
-                let orig_stack_len = self.state.stack.len();
-
-                let aiter = self.top_value();
-                let awaitable = if aiter.class().is(vm.ctx.types.async_generator) {
-                    vm.call_special_method(aiter, identifier!(vm, __anext__), ())?
-                } else {
-                    if !aiter.has_attr("__anext__", vm).unwrap_or(false) {
-                        // TODO: __anext__ must be protocol
-                        let msg = format!(
-                            "'async for' requires an iterator with __anext__ method, got {:.100}",
-                            aiter.class().name()
-                        );
-                        return Err(vm.new_type_error(msg));
-                    }
-                    let next_iter =
-                        vm.call_special_method(aiter, identifier!(vm, __anext__), ())?;
-
-                    // _PyCoro_GetAwaitableIter in CPython
-                    fn get_awaitable_iter(next_iter: &PyObject, vm: &VirtualMachine) -> PyResult {
-                        let gen_is_coroutine = |_| {
-                            // TODO: cpython gen_is_coroutine
-                            true
-                        };
-                        if next_iter.class().is(vm.ctx.types.coroutine_type)
-                            || gen_is_coroutine(next_iter)
-                        {
-                            return Ok(next_iter.to_owned());
-                        }
-                        // TODO: error handling
-                        vm.call_special_method(next_iter, identifier!(vm, __await__), ())
-                    }
-                    get_awaitable_iter(&next_iter, vm).map_err(|_| {
-                        vm.new_type_error(format!(
-                            "'async for' received an invalid object from __anext__: {:.200}",
-                            next_iter.class().name()
-                        ))
-                    })?
-                };
-                self.push_value(awaitable);
-                #[cfg(debug_assertions)]
-                debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
-                Ok(None)
-            }
-            bytecode::Instruction::EndAsyncFor => {
-                let exc = self.pop_value();
-                let except_block = self.pop_block(); // pushed by TryExcept unwind
-                debug_assert_eq!(except_block.level, self.state.stack.len());
-                let _async_iterator = self.pop_value(); // __anext__ provider in the loop
-                if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) {
-                    vm.take_exception().expect("Should have exception in stack");
+            bytecode::Instruction::PopException => {
+                let block = self.pop_block();
+                if let BlockType::ExceptHandler { prev_exc } = block.typ {
+                    vm.set_exception(prev_exc);
                     Ok(None)
                 } else {
-                    Err(exc.downcast().unwrap())
+                    self.fatal("block type must be ExceptHandler here.")
                 }
             }
-            bytecode::Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
-            bytecode::Instruction::MakeFunction => self.execute_make_function(vm),
-            bytecode::Instruction::SetFunctionAttribute { attr } => {
-                self.execute_set_function_attribute(vm, attr.get(arg))
-            }
-            bytecode::Instruction::CallFunctionPositional { nargs } => {
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::CallFunctionKeyword { nargs } => {
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::LoadMethod { idx } => {
-                let obj = self.pop_value();
-                let method_name = self.code.names[idx.get(arg) as usize];
-                let method = PyMethod::get(obj, method_name, vm)?;
-                let (target, is_method, func) = match method {
-                    PyMethod::Function { target, func } => (target, true, func),
-                    PyMethod::Attribute(val) => (vm.ctx.none(), false, val),
-                };
-                // TODO: figure out a better way to communicate PyMethod::Attribute - CPython uses
-                // target==NULL, maybe we could use a sentinel value or something?
-                self.push_value(target);
-                self.push_value(vm.ctx.new_bool(is_method).into());
-                self.push_value(func);
-                Ok(None)
-            }
-            bytecode::Instruction::CallMethodPositional { nargs } => {
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodKeyword { nargs } => {
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodEx { has_kwargs } => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::Jump { target } => {
-                self.jump(target.get(arg));
-                Ok(None)
-            }
-            bytecode::Instruction::PopJumpIfTrue { target } => {
-                self.pop_jump_if(vm, target.get(arg), true)
-            }
             bytecode::Instruction::PopJumpIfFalse { target } => {
                 self.pop_jump_if(vm, target.get(arg), false)
             }
-            bytecode::Instruction::JumpIfTrueOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), true)
-            }
-            bytecode::Instruction::JumpIfFalseOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), false)
+            bytecode::Instruction::PopJumpIfTrue { target } => {
+                self.pop_jump_if(vm, target.get(arg), true)
             }
+            bytecode::Instruction::PrintExpr => self.print_expr(vm),
 
             bytecode::Instruction::Raise { kind } => self.execute_raise(vm, kind.get(arg)),
+            bytecode::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);
 
-            bytecode::Instruction::Break { target } => self.unwind_blocks(
-                vm,
-                UnwindReason::Break {
-                    target: target.get(arg),
-                },
-            ),
-            bytecode::Instruction::Continue { target } => self.unwind_blocks(
-                vm,
-                UnwindReason::Continue {
-                    target: target.get(arg),
-                },
-            ),
-            bytecode::Instruction::PrintExpr => self.print_expr(vm),
-            bytecode::Instruction::LoadBuildClass => {
-                self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
+                // Check for interrupts if not resuming from yield_from
+                // if resume_type < bytecode::ResumeType::AfterYieldFrom as u32 {
+                //     vm.check_signals()?;
+                // }
                 Ok(None)
             }
-            bytecode::Instruction::UnpackSequence { size } => {
-                self.unpack_sequence(size.get(arg), vm)
-            }
-            bytecode::Instruction::UnpackEx { args } => {
-                let args = args.get(arg);
-                self.execute_unpack_ex(vm, args.before, args.after)
-            }
-            bytecode::Instruction::FormatValue { conversion } => {
-                self.format_value(conversion.get(arg), vm)
+            bytecode::Instruction::ReturnConst { idx } => {
+                let value = self.code.constants[idx.get(arg) as usize].clone().into();
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
-            bytecode::Instruction::PopException => {
-                let block = self.pop_block();
-                if let BlockType::ExceptHandler { prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    Ok(None)
-                } else {
-                    self.fatal("block type must be ExceptHandler here.")
-                }
+            bytecode::Instruction::ReturnValue => {
+                let value = self.pop_value();
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
             }
             bytecode::Instruction::Reverse { amount } => {
                 let stack_len = self.state.stack.len();
                 self.state.stack[stack_len - amount.get(arg) as usize..stack_len].reverse();
                 Ok(None)
             }
-            bytecode::Instruction::ExtendedArg => {
-                *extend_arg = true;
+            bytecode::Instruction::SetAdd { i } => {
+                let item = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let set: &Py<PySet> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
+                };
+                set.add(item, vm)?;
                 Ok(None)
             }
-            bytecode::Instruction::MatchMapping => {
-                // Pop and push back the subject to keep it on stack
-                let subject = self.pop_value();
-
-                // Check if the type has the MAPPING flag
-                let is_mapping = subject.class().slots.flags.contains(PyTypeFlags::MAPPING);
-
-                self.push_value(subject);
-                self.push_value(vm.ctx.new_bool(is_mapping).into());
+            bytecode::Instruction::SetFunctionAttribute { attr } => {
+                self.execute_set_function_attribute(vm, attr.get(arg))
+            }
+            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
+            bytecode::Instruction::SetupAsyncWith { end } => {
+                let enter_res = self.pop_value();
+                self.push_block(BlockType::Finally {
+                    handler: end.get(arg),
+                });
+                self.push_value(enter_res);
                 Ok(None)
             }
-            bytecode::Instruction::MatchSequence => {
-                // Pop and push back the subject to keep it on stack
-                let subject = self.pop_value();
-
-                // Check if the type has the SEQUENCE flag
-                let is_sequence = subject.class().slots.flags.contains(PyTypeFlags::SEQUENCE);
-
-                self.push_value(subject);
-                self.push_value(vm.ctx.new_bool(is_sequence).into());
+            bytecode::Instruction::SetupExcept { handler } => {
+                self.push_block(BlockType::TryExcept {
+                    handler: handler.get(arg),
+                });
                 Ok(None)
             }
-            bytecode::Instruction::MatchKeys => {
-                // MATCH_KEYS doesn't pop subject and keys, only reads them
-                let keys_tuple = self.top_value(); // stack[-1]
-                let subject = self.nth_value(1); // stack[-2]
-
-                // Check if subject is a mapping and extract values for keys
-                if subject.class().slots.flags.contains(PyTypeFlags::MAPPING) {
-                    let keys = keys_tuple.downcast_ref::<PyTuple>().unwrap();
-                    let mut values = Vec::new();
-                    let mut all_match = true;
-
-                    // We use the two argument form of map.get(key, default) for two reasons:
-                    // - Atomically check for a key and get its value without error handling.
-                    // - Don't cause key creation or resizing in dict subclasses like
-                    //   collections.defaultdict that define __missing__ (or similar).
-                    // See CPython's _PyEval_MatchKeys
-
-                    if let Some(get_method) = vm
-                        .get_method(subject.to_owned(), vm.ctx.intern_str("get"))
-                        .transpose()?
-                    {
-                        // dummy = object()
-                        // CPython: dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);
-                        let dummy = vm
-                            .ctx
-                            .new_base_object(vm.ctx.types.object_type.to_owned(), None);
-
-                        for key in keys {
-                            // value = map.get(key, dummy)
-                            match get_method.call((key.as_object(), dummy.clone()), vm) {
-                                Ok(value) => {
-                                    // if value == dummy: key not in map!
-                                    if value.is(&dummy) {
-                                        all_match = false;
-                                        break;
-                                    }
-                                    values.push(value);
-                                }
-                                Err(e) => return Err(e),
-                            }
-                        }
-                    } else {
-                        // Fallback if .get() method is not available (shouldn't happen for mappings)
-                        for key in keys {
-                            match subject.get_item(key.as_object(), vm) {
-                                Ok(value) => values.push(value),
-                                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
-                                    all_match = false;
-                                    break;
-                                }
-                                Err(e) => return Err(e),
-                            }
-                        }
-                    }
-
-                    if all_match {
-                        // Push values tuple on successful match
-                        self.push_value(vm.ctx.new_tuple(values).into());
-                    } else {
-                        // No match - push None
-                        self.push_value(vm.ctx.none());
-                    }
-                } else {
-                    // Not a mapping - push None
-                    self.push_value(vm.ctx.none());
-                }
+            bytecode::Instruction::SetupFinally { handler } => {
+                self.push_block(BlockType::Finally {
+                    handler: handler.get(arg),
+                });
                 Ok(None)
             }
-            bytecode::Instruction::MatchClass(nargs) => {
-                // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
-                // nargs is the number of positional sub-patterns.
-                let kwd_attrs = self.pop_value();
-                let kwd_attrs = kwd_attrs.downcast_ref::<PyTuple>().unwrap();
-                let cls = self.pop_value();
-                let subject = self.pop_value();
-                let nargs_val = nargs.get(arg) as usize;
-
-                // Check if subject is an instance of cls
-                if subject.is_instance(cls.as_ref(), vm)? {
-                    let mut extracted = vec![];
-
-                    // Get __match_args__ for positional arguments if nargs > 0
-                    if nargs_val > 0 {
-                        // Get __match_args__ from the class
-                        let match_args =
-                            vm.get_attribute_opt(cls.clone(), identifier!(vm, __match_args__))?;
+            bytecode::Instruction::SetupLoop => {
+                self.push_block(BlockType::Loop);
+                Ok(None)
+            }
+            bytecode::Instruction::SetupWith { end } => {
+                let context_manager = self.pop_value();
+                let error_string = || -> String {
+                    format!(
+                        "'{:.200}' object does not support the context manager protocol",
+                        context_manager.class().name(),
+                    )
+                };
+                let enter_res = vm
+                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
+                    .ok_or_else(|| vm.new_type_error(error_string()))?
+                    .invoke((), vm)?;
 
-                        if let Some(match_args) = match_args {
-                            // Convert to tuple
-                            let match_args = match match_args.downcast_exact::<PyTuple>(vm) {
-                                Ok(tuple) => tuple,
-                                Err(match_args) => {
-                                    // __match_args__ must be a tuple
-                                    // Get type names for error message
-                                    let type_name = cls
-                                        .downcast::<crate::builtins::PyType>()
-                                        .map(|t| t.__name__(vm).as_str().to_owned())
-                                        .unwrap_or_else(|_| String::from("?"));
-                                    let match_args_type_name = match_args.class().__name__(vm);
-                                    return Err(vm.new_type_error(format!(
-                                        "{}.__match_args__ must be a tuple (got {})",
-                                        type_name, match_args_type_name
-                                    )));
-                                }
-                            };
+                let exit = context_manager
+                    .get_attr(identifier!(vm, __exit__), vm)
+                    .map_err(|_exc| {
+                        vm.new_type_error({
+                            format!("{} (missed __exit__ method)", error_string())
+                        })
+                    })?;
+                self.push_value(exit);
+                self.push_block(BlockType::Finally {
+                    handler: end.get(arg),
+                });
+                self.push_value(enter_res);
+                Ok(None)
+            }
+            bytecode::Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
+            bytecode::Instruction::StoreDeref(i) => {
+                let value = self.pop_value();
+                self.cells_frees[i.get(arg) as usize].set(Some(value));
+                Ok(None)
+            }
+            bytecode::Instruction::StoreFast(idx) => {
+                let value = self.pop_value();
+                self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
+                Ok(None)
+            }
+            bytecode::Instruction::StoreGlobal(idx) => {
+                let value = self.pop_value();
+                self.globals
+                    .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::StoreLocal(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let value = self.pop_value();
+                self.locals.mapping().ass_subscript(name, Some(value), vm)?;
+                Ok(None)
+            }
+            bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
+            bytecode::Instruction::Subscript => self.execute_subscript(vm),
+            bytecode::Instruction::Swap { index } => {
+                let len = self.state.stack.len();
+                debug_assert!(len > 0, "stack underflow in SWAP");
+                let i = len - 1; // TOS index
+                let index_val = index.get(arg) as usize;
+                // CPython: SWAP(n) swaps TOS with PEEK(n) where PEEK(n) = stack_pointer[-n]
+                // This means swap TOS with the element at index (len - n)
+                debug_assert!(
+                    index_val <= len,
+                    "SWAP index {} exceeds stack size {}",
+                    index_val,
+                    len
+                );
+                let j = len - index_val;
+                self.state.stack.swap(i, j);
+                Ok(None)
+            }
+            bytecode::Instruction::ToBool => {
+                let obj = self.pop_value();
+                let bool_val = obj.try_to_bool(vm)?;
+                self.push_value(vm.ctx.new_bool(bool_val).into());
+                Ok(None)
+            }
+            bytecode::Instruction::UnaryOperation { op } => self.execute_unary_op(vm, op.get(arg)),
+            bytecode::Instruction::UnpackEx { args } => {
+                let args = args.get(arg);
+                self.execute_unpack_ex(vm, args.before, args.after)
+            }
+            bytecode::Instruction::UnpackSequence { size } => {
+                self.unpack_sequence(size.get(arg), vm)
+            }
+            bytecode::Instruction::WithCleanupFinish => {
+                let block = self.pop_block();
+                let (reason, prev_exc) = match block.typ {
+                    BlockType::FinallyHandler { reason, prev_exc } => (reason, prev_exc),
+                    _ => self.fatal("WithCleanupFinish expects a FinallyHandler block on stack"),
+                };
 
-                            // Check if we have enough match args
-                            if match_args.len() < nargs_val {
-                                return Err(vm.new_type_error(format!(
-                                    "class pattern accepts at most {} positional sub-patterns ({} given)",
-                                    match_args.len(),
-                                    nargs_val
-                                )));
-                            }
+                vm.set_exception(prev_exc);
 
-                            // Extract positional attributes
-                            for i in 0..nargs_val {
-                                let attr_name = &match_args[i];
-                                let attr_name_str = match attr_name.downcast_ref::<PyStr>() {
-                                    Some(s) => s,
-                                    None => {
-                                        return Err(vm.new_type_error(
-                                            "__match_args__ elements must be strings".to_string(),
-                                        ));
-                                    }
-                                };
-                                match subject.get_attr(attr_name_str, vm) {
-                                    Ok(value) => extracted.push(value),
-                                    Err(e)
-                                        if e.fast_isinstance(vm.ctx.exceptions.attribute_error) =>
-                                    {
-                                        // Missing attribute → non-match
-                                        self.push_value(vm.ctx.none());
-                                        return Ok(None);
-                                    }
-                                    Err(e) => return Err(e),
-                                }
-                            }
-                        } else {
-                            // No __match_args__, check if this is a type with MATCH_SELF behavior
-                            // For built-in types like bool, int, str, list, tuple, dict, etc.
-                            // they match the subject itself as the single positional argument
-                            let is_match_self_type = cls
-                                .downcast::<PyType>()
-                                .is_ok_and(|t| t.slots.flags.contains(PyTypeFlags::_MATCH_SELF));
+                let suppress_exception = self.pop_value().try_to_bool(vm)?;
 
-                            if is_match_self_type {
-                                if nargs_val == 1 {
-                                    // Match the subject itself as the single positional argument
-                                    extracted.push(subject.clone());
-                                } else if nargs_val > 1 {
-                                    // Too many positional arguments for MATCH_SELF
-                                    return Err(vm.new_type_error(
-                                        "class pattern accepts at most 1 positional sub-pattern for MATCH_SELF types"
-                                            .to_string(),
-                                    ));
-                                }
-                            } else {
-                                // No __match_args__ and not a MATCH_SELF type
-                                if nargs_val > 0 {
-                                    return Err(vm.new_type_error(
-                                        "class pattern defines no positional sub-patterns (__match_args__ missing)"
-                                            .to_string(),
-                                    ));
-                                }
-                            }
-                        }
-                    }
+                if suppress_exception {
+                    Ok(None)
+                } else if let Some(reason) = reason {
+                    self.unwind_blocks(vm, reason)
+                } else {
+                    Ok(None)
+                }
+            }
+            bytecode::Instruction::WithCleanupStart => {
+                let block = self.current_block().unwrap();
+                let reason = match block.typ {
+                    BlockType::FinallyHandler { reason, .. } => reason,
+                    _ => self.fatal("WithCleanupStart expects a FinallyHandler block on stack"),
+                };
+                let exc = match reason {
+                    Some(UnwindReason::Raising { exception }) => Some(exception),
+                    _ => None,
+                };
 
-                    // Extract keyword attributes
-                    for name in kwd_attrs {
-                        let name_str = name.downcast_ref::<PyStr>().unwrap();
-                        match subject.get_attr(name_str, vm) {
-                            Ok(value) => extracted.push(value),
-                            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => {
-                                self.push_value(vm.ctx.none());
-                                return Ok(None);
-                            }
-                            Err(e) => return Err(e),
-                        }
-                    }
+                let exit = self.top_value();
 
-                    self.push_value(vm.ctx.new_tuple(extracted).into());
+                let args = if let Some(exc) = exc {
+                    vm.split_exception(exc)
                 } else {
-                    // Not an instance, push None
-                    self.push_value(vm.ctx.none());
-                }
+                    (vm.ctx.none(), vm.ctx.none(), vm.ctx.none())
+                };
+                let exit_res = exit.call(args, vm)?;
+                self.replace_top(exit_res);
+
                 Ok(None)
             }
+            bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
+            bytecode::Instruction::YieldValue => {
+                let value = self.pop_value();
+                let value = if self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
+                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
+                } else {
+                    value
+                };
+                Ok(Some(ExecutionResult::Yield(value)))
+            }
         }
     }