diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 7681760ea65..41746996ceb 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -38,6 +38,7 @@ CODEUNIT
 CONIN
 CONOUT
 constevaluator
+consti
 CONVFUNC
 convparam
 copyslot
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
index 72ce4c7350b..6f7d8c15236 100644
--- a/crates/codegen/src/compile.rs
+++ b/crates/codegen/src/compile.rs
@@ -310,9 +310,9 @@ macro_rules! emit {
         $c.emit_arg($arg_val, |x| $enum::$op { $arg: x })
     };
 
-    // Tuple variant (e.g., Foo::B(42))
+    // Tuple variant (e.g., Foo::B(42)). Should never be reached, here for validation.
     ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
-        $c.emit_arg($arg_val, $enum::$op)
+        panic!("No instruction should be defined as `Instruction::Foo(value)` use `Instruction::Foo { x: value }` instead")
     };
 
     // No-arg variant (e.g., Foo::C)
@@ -572,13 +572,13 @@ impl Compiler {
             let total_size = n + pushed;
             match collection_type {
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size: total_size });
+                    emit!(self, Instruction::BuildList { count: total_size });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size: total_size });
+                    emit!(self, Instruction::BuildSet { count: total_size });
                 }
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size: total_size });
+                    emit!(self, Instruction::BuildTuple { count: total_size });
                 }
             }
             return Ok(());
@@ -594,13 +594,13 @@ impl Compiler {
                 if !sequence_built {
                     match collection_type {
                         CollectionType::List => {
-                            emit!(self, Instruction::BuildList { size: i + pushed });
+                            emit!(self, Instruction::BuildList { count: i + pushed });
                         }
                         CollectionType::Set => {
-                            emit!(self, Instruction::BuildSet { size: i + pushed });
+                            emit!(self, Instruction::BuildSet { count: i + pushed });
                         }
                         CollectionType::Tuple => {
-                            emit!(self, Instruction::BuildList { size: i + pushed });
+                            emit!(self, Instruction::BuildList { count: i + pushed });
                         }
                     }
                     sequence_built = true;
@@ -647,13 +647,13 @@ impl Compiler {
         if !sequence_built {
             match collection_type {
                 CollectionType::List => {
-                    emit!(self, Instruction::BuildList { size: i + pushed });
+                    emit!(self, Instruction::BuildList { count: i + pushed });
                 }
                 CollectionType::Set => {
-                    emit!(self, Instruction::BuildSet { size: i + pushed });
+                    emit!(self, Instruction::BuildSet { count: i + pushed });
                 }
                 CollectionType::Tuple => {
-                    emit!(self, Instruction::BuildTuple { size: i + pushed });
+                    emit!(self, Instruction::BuildTuple { count: i + pushed });
                 }
             }
         } else if collection_type == CollectionType::Tuple {
@@ -948,7 +948,7 @@ impl Compiler {
                         )));
                     }
                 };
-                self.emit_arg(idx, Instruction::LoadDeref);
+                emit!(self, Instruction::LoadDeref { i: idx });
 
                 // Load first parameter (typically 'self').
                 // Safety: can_optimize_super_call() ensures argcount > 0, and
@@ -1164,7 +1164,7 @@ impl Compiler {
 
         self.current_block().instructions.push(ir::InstructionInfo {
             instr: Instruction::Resume {
-                arg: OpArgMarker::marker(),
+                context: OpArgMarker::marker(),
             }
             .into(),
             arg: OpArg::new(u32::from(bytecode::ResumeType::AtFuncStart)),
@@ -1283,7 +1283,7 @@ impl Compiler {
     /// if format > VALUE_WITH_FAKE_GLOBALS (2): raise NotImplementedError
     fn emit_format_validation(&mut self) -> CompileResult<()> {
         // Load format parameter (first local variable, index 0)
-        emit!(self, Instruction::LoadFast(0));
+        emit!(self, Instruction::LoadFast { var_num: 0 });
 
         // Load VALUE_WITH_FAKE_GLOBALS constant (2)
         self.emit_load_const(ConstantData::Integer { value: 2.into() });
@@ -1292,13 +1292,13 @@ impl Compiler {
         emit!(
             self,
             Instruction::CompareOp {
-                op: ComparisonOperator::Greater
+                opname: ComparisonOperator::Greater
             }
         );
 
         // Jump to body if format <= 2 (comparison is false)
         let body_block = self.new_block();
-        emit!(self, Instruction::PopJumpIfFalse { target: body_block });
+        emit!(self, Instruction::PopJumpIfFalse { delta: body_block });
 
         // Raise NotImplementedError
         emit!(
@@ -1310,7 +1310,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::RaiseVarargs {
-                kind: bytecode::RaiseKind::Raise
+                argc: bytecode::RaiseKind::Raise
             }
         );
 
@@ -1378,7 +1378,7 @@ impl Compiler {
             FBlockType::ForLoop => {
                 // Pop the iterator
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopIter);
             }
@@ -1397,11 +1397,11 @@ impl Compiler {
             FBlockType::FinallyEnd => {
                 // codegen_unwind_fblock(FINALLY_END)
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopTop); // exc_value
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, PseudoInstruction::PopBlock);
                 emit!(self, Instruction::PopExcept);
@@ -1415,7 +1415,7 @@ impl Compiler {
 
                 // If preserving return value, swap it below __exit__
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 // Stack after swap: [..., return_value, __exit__] or [..., __exit__]
 
@@ -1427,11 +1427,11 @@ impl Compiler {
                 self.emit_load_const(ConstantData::None);
                 self.emit_load_const(ConstantData::None);
                 // Stack: [..., __exit__, NULL, None, None, None]
-                emit!(self, Instruction::Call { nargs: 3 });
+                emit!(self, Instruction::Call { argc: 3 });
 
                 // For async with, await the result
                 if matches!(info.fb_type, FBlockType::AsyncWith) {
-                    emit!(self, Instruction::GetAwaitable { arg: 2 });
+                    emit!(self, Instruction::GetAwaitable { r#where: 2 });
                     self.emit_load_const(ConstantData::None);
                     let _ = self.compile_yield_from_sequence(true)?;
                 }
@@ -1447,7 +1447,7 @@ impl Compiler {
                     emit!(self, PseudoInstruction::PopBlock);
                 }
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 // PopBlock for outer SETUP_CLEANUP (ExceptionHandler)
                 emit!(self, PseudoInstruction::PopBlock);
@@ -1463,7 +1463,7 @@ impl Compiler {
 
             FBlockType::PopValue => {
                 if preserve_tos {
-                    emit!(self, Instruction::Swap { index: 2 });
+                    emit!(self, Instruction::Swap { i: 2 });
                 }
                 emit!(self, Instruction::PopTop);
             }
@@ -1690,7 +1690,7 @@ impl Compiler {
                 value: value.into(),
             });
             let doc = self.name("__doc__");
-            emit!(self, Instruction::StoreGlobal(doc))
+            emit!(self, Instruction::StoreGlobal { namei: doc })
         }
 
         // Handle annotations based on future_annotations flag
@@ -1704,7 +1704,7 @@ impl Compiler {
 
                 // PEP 649: Initialize __conditional_annotations__ set after __annotate__
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
             }
@@ -1743,7 +1743,7 @@ impl Compiler {
 
                 // PEP 649: Initialize __conditional_annotations__ set after __annotate__
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
             }
@@ -1768,7 +1768,7 @@ impl Compiler {
 
             if let ast::Stmt::Expr(ast::StmtExpr { value, .. }) = &last {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -1807,7 +1807,7 @@ impl Compiler {
                 ast::Stmt::FunctionDef(_) | ast::Stmt::ClassDef(_) => {
                     let pop_instructions = self.current_block().instructions.pop();
                     let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.current_block().instructions.push(store_inst);
                 }
                 _ => self.emit_load_const(ConstantData::None),
@@ -1972,61 +1972,57 @@ impl Compiler {
         // Generate appropriate instructions based on operation type
         match op_type {
             NameOp::Deref => {
-                let idx = match actual_scope {
+                let i = match actual_scope {
                     SymbolScope::Free => self.get_free_var_index(&name)?,
                     SymbolScope::Cell => self.get_cell_var_index(&name)?,
                     _ => unreachable!("Invalid scope for Deref operation"),
                 };
 
-                let op = match usage {
+                match usage {
                     NameUsage::Load => {
                         // ClassBlock (not inlined comp): LOAD_LOCALS first, then LOAD_FROM_DICT_OR_DEREF
                         if self.ctx.in_class && !self.ctx.in_func() {
                             emit!(self, Instruction::LoadLocals);
-                            Instruction::LoadFromDictOrDeref
+                            emit!(self, Instruction::LoadFromDictOrDeref { i });
                         // can_see_class_scope: LOAD_DEREF(__classdict__) first
                         } else if can_see_class_scope {
                             let classdict_idx = self.get_free_var_index("__classdict__")?;
-                            self.emit_arg(classdict_idx, Instruction::LoadDeref);
-                            Instruction::LoadFromDictOrDeref
+                            emit!(self, Instruction::LoadDeref { i: classdict_idx });
+                            emit!(self, Instruction::LoadFromDictOrDeref { i });
                         } else {
-                            Instruction::LoadDeref
+                            emit!(self, Instruction::LoadDeref { i });
                         }
                     }
-                    NameUsage::Store => Instruction::StoreDeref,
-                    NameUsage::Delete => Instruction::DeleteDeref,
+                    NameUsage::Store => emit!(self, Instruction::StoreDeref { i }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteDeref { i }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::Fast => {
-                let idx = self.get_local_var_index(&name)?;
-                let op = match usage {
-                    NameUsage::Load => Instruction::LoadFast,
-                    NameUsage::Store => Instruction::StoreFast,
-                    NameUsage::Delete => Instruction::DeleteFast,
+                let var_num = self.get_local_var_index(&name)?;
+                match usage {
+                    NameUsage::Load => emit!(self, Instruction::LoadFast { var_num }),
+                    NameUsage::Store => emit!(self, Instruction::StoreFast { var_num }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteFast { var_num }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::Global => {
-                let idx = self.get_global_name_index(&name);
-                let op = match usage {
+                let namei = self.get_global_name_index(&name);
+                match usage {
                     NameUsage::Load => {
-                        self.emit_load_global(idx, false);
+                        self.emit_load_global(namei, false);
                         return Ok(());
                     }
-                    NameUsage::Store => Instruction::StoreGlobal,
-                    NameUsage::Delete => Instruction::DeleteGlobal,
+                    NameUsage::Store => emit!(self, Instruction::StoreGlobal { namei }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteGlobal { namei }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::Name => {
-                let idx = self.get_global_name_index(&name);
-                let op = match usage {
-                    NameUsage::Load => Instruction::LoadName,
-                    NameUsage::Store => Instruction::StoreName,
-                    NameUsage::Delete => Instruction::DeleteName,
+                let namei = self.get_global_name_index(&name);
+                match usage {
+                    NameUsage::Load => emit!(self, Instruction::LoadName { namei }),
+                    NameUsage::Store => emit!(self, Instruction::StoreName { namei }),
+                    NameUsage::Delete => emit!(self, Instruction::DeleteName { namei }),
                 };
-                self.emit_arg(idx, op);
             }
             NameOp::DictOrGlobals => {
                 // PEP 649: First check classdict (from __classdict__ freevar), then globals
@@ -2035,15 +2031,15 @@ impl Compiler {
                     NameUsage::Load => {
                         // Load __classdict__ first (it's a free variable in annotation scope)
                         let classdict_idx = self.get_free_var_index("__classdict__")?;
-                        self.emit_arg(classdict_idx, Instruction::LoadDeref);
-                        self.emit_arg(idx, Instruction::LoadFromDictOrGlobals);
+                        emit!(self, Instruction::LoadDeref { i: classdict_idx });
+                        emit!(self, Instruction::LoadFromDictOrGlobals { i: idx });
                     }
                     // Store/Delete in annotation scope should use Name ops
                     NameUsage::Store => {
-                        self.emit_arg(idx, Instruction::StoreName);
+                        emit!(self, Instruction::StoreName { namei: idx });
                     }
                     NameUsage::Delete => {
-                        self.emit_arg(idx, Instruction::DeleteName);
+                        emit!(self, Instruction::DeleteName { namei: idx });
                     }
                 }
             }
@@ -2085,15 +2081,15 @@ impl Compiler {
                         value: num_traits::Zero::zero(),
                     });
                     self.emit_load_const(ConstantData::None);
-                    let idx = self.name(&name.name);
-                    emit!(self, Instruction::ImportName { idx });
+                    let namei = self.name(&name.name);
+                    emit!(self, Instruction::ImportName { namei });
                     if let Some(alias) = &name.asname {
                         let parts: Vec<&str> = name.name.split('.').skip(1).collect();
                         for (i, part) in parts.iter().enumerate() {
-                            let idx = self.name(part);
-                            emit!(self, Instruction::ImportFrom { idx });
+                            let namei = self.name(part);
+                            emit!(self, Instruction::ImportFrom { namei });
                             if i < parts.len() - 1 {
-                                emit!(self, Instruction::Swap { index: 2 });
+                                emit!(self, Instruction::Swap { i: 2 });
                                 emit!(self, Instruction::PopTop);
                             }
                         }
@@ -2141,7 +2137,7 @@ impl Compiler {
 
                 let module_name = module.as_ref().map_or("", |s| s.as_str());
                 let module_idx = self.name(module_name);
-                emit!(self, Instruction::ImportName { idx: module_idx });
+                emit!(self, Instruction::ImportName { namei: module_idx });
 
                 if import_star {
                     // from .... import *
@@ -2159,7 +2155,7 @@ impl Compiler {
                         let name = &name;
                         let idx = self.name(name.name.as_str());
                         // import symbol from module:
-                        emit!(self, Instruction::ImportFrom { idx });
+                        emit!(self, Instruction::ImportFrom { namei: idx });
 
                         // Store module under proper name:
                         if let Some(alias) = &name.asname {
@@ -2212,12 +2208,7 @@ impl Compiler {
 
                         self.compile_jump_if(test, false, next_block)?;
                         self.compile_statements(body)?;
-                        emit!(
-                            self,
-                            PseudoInstruction::Jump {
-                                target: after_block
-                            }
-                        );
+                        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
                         for clause in rest {
                             self.switch_to_block(next_block);
@@ -2228,12 +2219,7 @@ impl Compiler {
                                 unreachable!() // must be elif
                             }
                             self.compile_statements(&clause.body)?;
-                            emit!(
-                                self,
-                                PseudoInstruction::Jump {
-                                    target: after_block
-                                }
-                            );
+                            emit!(self, PseudoInstruction::Jump { delta: after_block });
                         }
 
                         self.switch_to_block(next_block);
@@ -2283,7 +2269,7 @@ impl Compiler {
                     None => bytecode::RaiseKind::BareRaise,
                 };
                 self.set_source_range(*range);
-                emit!(self, Instruction::RaiseVarargs { kind });
+                emit!(self, Instruction::RaiseVarargs { argc: kind });
                 // Start a new block so dead code after raise doesn't
                 // corrupt the except stack in label_exception_targets
                 let dead = self.new_block();
@@ -2357,16 +2343,16 @@ impl Compiler {
                     match msg {
                         Some(e) => {
                             self.compile_expression(e)?;
-                            emit!(self, Instruction::Call { nargs: 1 });
+                            emit!(self, Instruction::Call { argc: 1 });
                         }
                         None => {
-                            emit!(self, Instruction::Call { nargs: 0 });
+                            emit!(self, Instruction::Call { argc: 0 });
                         }
                     }
                     emit!(
                         self,
                         Instruction::RaiseVarargs {
-                            kind: bytecode::RaiseKind::Raise,
+                            argc: bytecode::RaiseKind::Raise,
                         }
                     );
 
@@ -2426,7 +2412,7 @@ impl Compiler {
 
                 for (i, target) in targets.iter().enumerate() {
                     if i + 1 != targets.len() {
-                        emit!(self, Instruction::Copy { index: 1_u32 });
+                        emit!(self, Instruction::Copy { i: 1 });
                     }
                     self.compile_store(target)?;
                 }
@@ -2518,22 +2504,22 @@ impl Compiler {
                     // Stack: [type_params_tuple, value_closure]
 
                     // Swap so unpack_sequence reverse gives correct order
-                    emit!(self, Instruction::Swap { index: 2_u32 });
+                    emit!(self, Instruction::Swap { i: 2 });
                     // Stack: [value_closure, type_params_tuple]
 
                     // Build tuple and return from TypeParams scope
-                    emit!(self, Instruction::BuildTuple { size: 2 });
+                    emit!(self, Instruction::BuildTuple { count: 2 });
                     emit!(self, Instruction::ReturnValue);
 
                     let code = self.exit_scope();
                     self.ctx = prev_ctx;
                     self.make_closure(code, bytecode::MakeFunctionFlags::empty())?;
                     emit!(self, Instruction::PushNull);
-                    emit!(self, Instruction::Call { nargs: 0 });
+                    emit!(self, Instruction::Call { argc: 0 });
 
                     // Unpack: (value_closure, type_params_tuple)
                     // UnpackSequence reverses → stack: [name, type_params_tuple, value_closure]
-                    emit!(self, Instruction::UnpackSequence { size: 2 });
+                    emit!(self, Instruction::UnpackSequence { count: 2 });
                 } else {
                     // Push None for type_params
                     self.emit_load_const(ConstantData::None);
@@ -2571,7 +2557,7 @@ impl Compiler {
                 }
 
                 // Build tuple of 3 elements and call intrinsic
-                emit!(self, Instruction::BuildTuple { size: 3 });
+                emit!(self, Instruction::BuildTuple { count: 3 });
                 emit!(
                     self,
                     Instruction::CallIntrinsic1 {
@@ -2592,8 +2578,8 @@ impl Compiler {
             }
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::DeleteAttr { idx });
+                let namei = self.name(attr.as_str());
+                emit!(self, Instruction::DeleteAttr { namei });
             }
             ast::Expr::Subscript(ast::ExprSubscript {
                 value, slice, ctx, ..
@@ -2672,7 +2658,7 @@ impl Compiler {
     /// applying decorators bottom-up (innermost first).
     fn apply_decorators(&mut self, decorator_list: &[ast::Decorator]) {
         for _ in decorator_list {
-            emit!(self, Instruction::Call { nargs: 1 });
+            emit!(self, Instruction::Call { argc: 1 });
         }
     }
 
@@ -2716,7 +2702,7 @@ impl Compiler {
         if allow_starred && matches!(expr, ast::Expr::Starred(_)) {
             if let ast::Expr::Starred(starred) = expr {
                 self.compile_expression(&starred.value)?;
-                emit!(self, Instruction::UnpackSequence { size: 1 });
+                emit!(self, Instruction::UnpackSequence { count: 1 });
             }
         } else {
             self.compile_expression(expr)?;
@@ -2785,7 +2771,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
                 ast::TypeParam::ParamSpec(ast::TypeParamParamSpec { name, default, .. }) => {
@@ -2810,7 +2796,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
                 ast::TypeParam::TypeVarTuple(ast::TypeParamTypeVarTuple {
@@ -2838,7 +2824,7 @@ impl Compiler {
                         );
                     }
 
-                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    emit!(self, Instruction::Copy { i: 1 });
                     self.store_name(name.as_ref())?;
                 }
             };
@@ -2846,7 +2832,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::BuildTuple {
-                size: u32::try_from(type_params.len()).unwrap(),
+                count: u32::try_from(type_params.len()).unwrap(),
             }
         );
         Ok(())
@@ -2892,7 +2878,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: setup_target
+                    delta: setup_target
                 }
             );
             // Store finally body in fb_datum for unwind_fblock to compile inline
@@ -2936,7 +2922,7 @@ impl Compiler {
             }
 
             // Jump to end (skip exception path blocks)
-            emit!(self, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: end_block });
 
             if let Some(finally_except) = finally_except_block {
                 // Restore sub_tables for exception path compilation
@@ -2949,7 +2935,7 @@ impl Compiler {
                 self.switch_to_block(finally_except);
                 // SETUP_CLEANUP before PUSH_EXC_INFO
                 if let Some(cleanup) = finally_cleanup_block {
-                    emit!(self, PseudoInstruction::SetupCleanup { target: cleanup });
+                    emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
                 }
                 emit!(self, Instruction::PushExcInfo);
                 if let Some(cleanup) = finally_cleanup_block {
@@ -2969,7 +2955,7 @@ impl Compiler {
                 // Stack: [prev_exc, exc] -> COPY 2 -> [prev_exc, exc, prev_exc]
                 // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
                 // Stack after POP_EXCEPT: [prev_exc, exc]
-                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { i: 2 });
                 emit!(self, Instruction::PopExcept);
 
                 // RERAISE 0: re-raise the original exception to outer handler
@@ -2978,7 +2964,7 @@ impl Compiler {
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::Copy { index: 3_u32 });
+                emit!(self, Instruction::Copy { i: 3 });
                 emit!(self, Instruction::PopExcept);
                 emit!(self, Instruction::Reraise { depth: 1 });
             }
@@ -2991,14 +2977,14 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupFinally {
-                target: handler_block
+                delta: handler_block
             }
         );
         self.push_fblock(FBlockType::TryExcept, handler_block, handler_block)?;
         self.compile_statements(body)?;
         emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(FBlockType::TryExcept);
-        emit!(self, PseudoInstruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { delta: else_block });
 
         // except handlers:
         self.switch_to_block(handler_block);
@@ -3012,7 +2998,7 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupCleanup {
-                target: cleanup_block
+                delta: cleanup_block
             }
         );
         self.push_fblock(FBlockType::ExceptionHandler, cleanup_block, cleanup_block)?;
@@ -3043,7 +3029,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: next_handler
+                        delta: next_handler
                     }
                 );
                 // Stack: [prev_exc, exc]
@@ -3065,12 +3051,7 @@ impl Compiler {
             let handler_cleanup_block = if name.is_some() {
                 // SETUP_CLEANUP(cleanup_end) for named handler
                 let cleanup_end = self.new_block();
-                emit!(
-                    self,
-                    PseudoInstruction::SetupCleanup {
-                        target: cleanup_end
-                    }
-                );
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup_end });
                 self.push_fblock_full(
                     FBlockType::HandlerCleanup,
                     cleanup_end,
@@ -3098,7 +3079,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::JumpNoInterrupt {
-                    target: handler_normal_exit,
+                    delta: handler_normal_exit,
                 }
             );
 
@@ -3149,7 +3130,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::JumpNoInterrupt {
-                    target: finally_block,
+                    delta: finally_block,
                 }
             );
 
@@ -3178,7 +3159,7 @@ impl Compiler {
         // POP_EXCEPT: pop prev_exc from stack and restore -> [prev_exc, lasti, exc]
         // RERAISE 1: reraise with lasti
         self.switch_to_block(cleanup_block);
-        emit!(self, Instruction::Copy { index: 3_u32 });
+        emit!(self, Instruction::Copy { i: 3 });
         emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
@@ -3206,7 +3187,7 @@ impl Compiler {
             self.compile_statements(finalbody)?;
             // Jump to end_block to skip exception path blocks
             // This prevents fall-through to finally_except_block
-            emit!(self, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: end_block });
         }
 
         // finally (exception path)
@@ -3225,7 +3206,7 @@ impl Compiler {
             // SETUP_CLEANUP for finally body
             // Exceptions during finally body need to go to cleanup block
             if let Some(cleanup) = finally_cleanup_block {
-                emit!(self, PseudoInstruction::SetupCleanup { target: cleanup });
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
             }
             emit!(self, Instruction::PushExcInfo);
             if let Some(cleanup) = finally_cleanup_block {
@@ -3247,7 +3228,7 @@ impl Compiler {
             // Stack: [lasti, prev_exc, exc] -> COPY 2 -> [lasti, prev_exc, exc, prev_exc]
             // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
             // Stack after POP_EXCEPT: [lasti, prev_exc, exc]
-            emit!(self, Instruction::Copy { index: 2_u32 });
+            emit!(self, Instruction::Copy { i: 2 });
             emit!(self, Instruction::PopExcept);
 
             // RERAISE 0: re-raise the original exception to outer handler
@@ -3261,7 +3242,7 @@ impl Compiler {
         if let Some(cleanup) = finally_cleanup_block {
             self.switch_to_block(cleanup);
             // COPY 3: copy the exception from position 3
-            emit!(self, Instruction::Copy { index: 3_u32 });
+            emit!(self, Instruction::Copy { i: 3 });
             // POP_EXCEPT: restore prev_exc as current exception
             emit!(self, Instruction::PopExcept);
             // RERAISE 1: reraise with lasti from stack
@@ -3305,7 +3286,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: finally_block
+                    delta: finally_block
                 }
             );
             self.push_fblock_full(
@@ -3320,14 +3301,14 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupFinally {
-                target: handler_block
+                delta: handler_block
             }
         );
         self.push_fblock(FBlockType::TryExcept, handler_block, handler_block)?;
         self.compile_statements(body)?;
         emit!(self, PseudoInstruction::PopBlock);
         self.pop_fblock(FBlockType::TryExcept);
-        emit!(self, PseudoInstruction::Jump { target: else_block });
+        emit!(self, PseudoInstruction::Jump { delta: else_block });
 
         // Exception handler entry
         self.switch_to_block(handler_block);
@@ -3344,9 +3325,9 @@ impl Compiler {
 
         // Initialize handler stack before the loop
         // BUILD_LIST 0 + COPY 2 to set up [prev_exc, orig, list, rest]
-        emit!(self, Instruction::BuildList { size: 0 });
+        emit!(self, Instruction::BuildList { count: 0 });
         // Stack: [prev_exc, exc, []]
-        emit!(self, Instruction::Copy { index: 2 });
+        emit!(self, Instruction::Copy { i: 2 });
         // Stack: [prev_exc, orig, list, rest]
 
         let n = handlers.len();
@@ -3358,7 +3339,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::Jump {
-                    target: reraise_star_block
+                    delta: reraise_star_block
                 }
             );
         }
@@ -3398,11 +3379,11 @@ impl Compiler {
 
             // ADDOP_I(c, loc, COPY, 1);
             // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
-            emit!(self, Instruction::Copy { index: 1 });
+            emit!(self, Instruction::Copy { i: 1 });
             emit!(
                 self,
                 Instruction::PopJumpIfNone {
-                    target: no_match_block
+                    delta: no_match_block
                 }
             );
 
@@ -3423,7 +3404,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupCleanup {
-                    target: handler_except_block
+                    delta: handler_except_block
                 }
             );
             self.push_fblock_full(
@@ -3452,7 +3433,7 @@ impl Compiler {
             }
 
             // Jump to next handler
-            emit!(self, PseudoInstruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { delta: next_block });
 
             // Handler raised an exception (cleanup_end label)
             self.switch_to_block(handler_except_block);
@@ -3480,7 +3461,7 @@ impl Compiler {
 
             // JUMP except_with_error
             // We directly JUMP to next_block since no_match_block falls through to it
-            emit!(self, PseudoInstruction::Jump { target: next_block });
+            emit!(self, PseudoInstruction::Jump { delta: next_block });
 
             // No match - pop match (None)
             self.switch_to_block(no_match_block);
@@ -3505,7 +3486,7 @@ impl Compiler {
                 emit!(
                     self,
                     PseudoInstruction::Jump {
-                        target: reraise_star_block
+                        delta: reraise_star_block
                     }
                 );
             }
@@ -3529,14 +3510,14 @@ impl Compiler {
         // Stack: [prev_exc, result]
 
         // COPY 1
-        emit!(self, Instruction::Copy { index: 1 });
+        emit!(self, Instruction::Copy { i: 1 });
         // Stack: [prev_exc, result, result]
 
         // POP_JUMP_IF_NOT_NONE reraise
         emit!(
             self,
             Instruction::PopJumpIfNotNone {
-                target: reraise_block
+                delta: reraise_block
             }
         );
         // Stack: [prev_exc, result]
@@ -3556,7 +3537,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, PseudoInstruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { delta: end_block });
 
         // Reraise the result
         self.switch_to_block(reraise_block);
@@ -3564,7 +3545,7 @@ impl Compiler {
 
         // POP_BLOCK - no-op for us
         // SWAP 2
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { i: 2 });
         // Stack: [result, prev_exc]
 
         // POP_EXCEPT
@@ -3583,7 +3564,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: finally_block
+                    delta: finally_block
                 }
             );
             self.push_fblock_full(
@@ -3602,7 +3583,7 @@ impl Compiler {
             self.pop_fblock(FBlockType::FinallyTry);
         }
 
-        emit!(self, PseudoInstruction::Jump { target: end_block });
+        emit!(self, PseudoInstruction::Jump { delta: end_block });
 
         self.switch_to_block(end_block);
         if !finalbody.is_empty() {
@@ -3611,7 +3592,7 @@ impl Compiler {
 
             // Compile finally body inline for normal path
             self.compile_statements(finalbody)?;
-            emit!(self, PseudoInstruction::Jump { target: exit_block });
+            emit!(self, PseudoInstruction::Jump { delta: exit_block });
 
             // Restore sub_tables for exception path compilation
             if let Some(cursor) = sub_table_cursor
@@ -3625,7 +3606,7 @@ impl Compiler {
             emit!(self, Instruction::PushExcInfo);
 
             if let Some(cleanup) = finally_cleanup_block {
-                emit!(self, PseudoInstruction::SetupCleanup { target: cleanup });
+                emit!(self, PseudoInstruction::SetupCleanup { delta: cleanup });
                 self.push_fblock(FBlockType::FinallyEnd, cleanup, cleanup)?;
             }
 
@@ -3636,13 +3617,13 @@ impl Compiler {
                 self.pop_fblock(FBlockType::FinallyEnd);
             }
 
-            emit!(self, Instruction::Copy { index: 2_u32 });
+            emit!(self, Instruction::Copy { i: 2 });
             emit!(self, Instruction::PopExcept);
             emit!(self, Instruction::Reraise { depth: 0 });
 
             if let Some(cleanup) = finally_cleanup_block {
                 self.switch_to_block(cleanup);
-                emit!(self, Instruction::Copy { index: 3_u32 });
+                emit!(self, Instruction::Copy { i: 3 });
                 emit!(self, Instruction::PopExcept);
                 emit!(self, Instruction::Reraise { depth: 1 });
             }
@@ -3676,7 +3657,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildTuple {
-                    size: defaults.len().to_u32()
+                    count: defaults.len().to_u32()
                 }
             );
             funcflags |= bytecode::MakeFunctionFlags::DEFAULTS;
@@ -3701,7 +3682,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: kw_with_defaults.len().to_u32(),
+                    count: kw_with_defaults.len().to_u32(),
                 }
             );
             funcflags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
@@ -3845,7 +3826,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::BuildMap {
-                size: num_annotations,
+                count: num_annotations,
             }
         );
         emit!(self, Instruction::ReturnValue);
@@ -3975,7 +3956,7 @@ impl Compiler {
         if has_conditional {
             // PEP 649: Build dict incrementally, checking conditional annotations
             // Start with empty dict
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
 
             // Process each annotation
             for (idx, (name, annotation)) in annotations.iter().enumerate() {
@@ -3988,25 +3969,30 @@ impl Compiler {
                 // Class scope: LoadDeref (freevars), Module scope: LoadGlobal
                 if parent_scope_type == CompilerScope::Class {
                     let idx = self.get_free_var_index("__conditional_annotations__")?;
-                    emit!(self, Instruction::LoadDeref(idx));
+                    emit!(self, Instruction::LoadDeref { i: idx });
                 } else {
                     let cond_annotations_name = self.name("__conditional_annotations__");
                     self.emit_load_global(cond_annotations_name, false);
                 }
                 // CONTAINS_OP (in)
-                emit!(self, Instruction::ContainsOp(bytecode::Invert::No));
+                emit!(
+                    self,
+                    Instruction::ContainsOp {
+                        invert: bytecode::Invert::No
+                    }
+                );
                 // POP_JUMP_IF_FALSE not_set
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: not_set_block
+                        delta: not_set_block
                     }
                 );
 
                 // Annotation value
                 self.compile_annotation(annotation)?;
                 // COPY dict to TOS
-                emit!(self, Instruction::Copy { index: 2 });
+                emit!(self, Instruction::Copy { i: 2 });
                 // LOAD_CONST name
                 self.emit_load_const(ConstantData::Str {
                     value: self.mangle(name).into_owned().into(),
@@ -4036,7 +4022,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: num_annotations,
+                    count: num_annotations,
                 }
             );
             emit!(self, Instruction::ReturnValue);
@@ -4143,7 +4129,7 @@ impl Compiler {
 
             // Load defaults/kwdefaults with LOAD_FAST
             for i in 0..num_typeparam_args {
-                emit!(self, Instruction::LoadFast(i as u32));
+                emit!(self, Instruction::LoadFast { var_num: i as u32 });
             }
         }
 
@@ -4162,7 +4148,7 @@ impl Compiler {
         if is_generic {
             // SWAP to get function on top
             // Stack: [type_params_tuple, function] -> [function, type_params_tuple]
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
 
             // Call INTRINSIC_SET_FUNCTION_TYPE_PARAMS
             emit!(
@@ -4194,31 +4180,31 @@ impl Compiler {
                 match num_typeparam_args {
                     1 => {
                         // Stack: [arg1, closure]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, arg1]
                         emit!(self, Instruction::PushNull); // [closure, arg1, NULL]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, NULL, arg1]
                     }
                     2 => {
                         // Stack: [arg1, arg2, closure]
-                        emit!(self, Instruction::Swap { index: 3 }); // [closure, arg2, arg1]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1, arg2]
+                        emit!(self, Instruction::Swap { i: 3 }); // [closure, arg2, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, arg1, arg2]
                         emit!(self, Instruction::PushNull); // [closure, arg1, arg2, NULL]
-                        emit!(self, Instruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]
-                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]
+                        emit!(self, Instruction::Swap { i: 3 }); // [closure, NULL, arg2, arg1]
+                        emit!(self, Instruction::Swap { i: 2 }); // [closure, NULL, arg1, arg2]
                     }
                     _ => unreachable!("only defaults and kwdefaults are supported"),
                 }
                 emit!(
                     self,
                     Instruction::Call {
-                        nargs: num_typeparam_args as u32
+                        argc: num_typeparam_args as u32
                     }
                 );
             } else {
                 // Stack: [closure]
                 emit!(self, Instruction::PushNull);
                 // Stack: [closure, NULL]
-                emit!(self, Instruction::Call { nargs: 0 });
+                emit!(self, Instruction::Call { argc: 0 });
             }
         }
 
@@ -4323,14 +4309,14 @@ impl Compiler {
                     }
                 };
 
-                emit!(self, PseudoInstruction::LoadClosure(idx.to_u32()));
+                emit!(self, PseudoInstruction::LoadClosure { i: idx.to_u32() });
             }
 
             // Build tuple of closure variables
             emit!(
                 self,
                 Instruction::BuildTuple {
-                    size: code.freevars.len().to_u32(),
+                    count: code.freevars.len().to_u32(),
                 }
             );
         }
@@ -4351,7 +4337,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::CLOSURE
+                    flag: bytecode::MakeFunctionFlags::CLOSURE
                 }
             );
         }
@@ -4361,7 +4347,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::ANNOTATIONS
+                    flag: bytecode::MakeFunctionFlags::ANNOTATIONS
                 }
             );
         }
@@ -4371,7 +4357,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::ANNOTATE
+                    flag: bytecode::MakeFunctionFlags::ANNOTATE
                 }
             );
         }
@@ -4381,7 +4367,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
+                    flag: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
                 }
             );
         }
@@ -4391,7 +4377,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::DEFAULTS
+                    flag: bytecode::MakeFunctionFlags::DEFAULTS
                 }
             );
         }
@@ -4401,7 +4387,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::SetFunctionAttribute {
-                    attr: bytecode::MakeFunctionFlags::TYPE_PARAMS
+                    flag: bytecode::MakeFunctionFlags::TYPE_PARAMS
                 }
             );
         }
@@ -4485,20 +4471,30 @@ impl Compiler {
         let dunder_name = self.name("__name__");
         self.emit_load_global(dunder_name, false);
         let dunder_module = self.name("__module__");
-        emit!(self, Instruction::StoreName(dunder_module));
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: dunder_module
+            }
+        );
 
         // Store __qualname__
         self.emit_load_const(ConstantData::Str {
             value: qualname.into(),
         });
         let qualname_name = self.name("__qualname__");
-        emit!(self, Instruction::StoreName(qualname_name));
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: qualname_name
+            }
+        );
 
         // Store __doc__ only if there's an explicit docstring
         if let Some(doc) = doc_str {
             self.emit_load_const(ConstantData::Str { value: doc.into() });
             let doc_name = self.name("__doc__");
-            emit!(self, Instruction::StoreName(doc_name));
+            emit!(self, Instruction::StoreName { namei: doc_name });
         }
 
         // Store __firstlineno__ (new in Python 3.12+)
@@ -4506,24 +4502,39 @@ impl Compiler {
             value: BigInt::from(firstlineno),
         });
         let firstlineno_name = self.name("__firstlineno__");
-        emit!(self, Instruction::StoreName(firstlineno_name));
+        emit!(
+            self,
+            Instruction::StoreName {
+                namei: firstlineno_name
+            }
+        );
 
         // Set __type_params__ if we have type parameters
         if type_params.is_some() {
             // Load .type_params from enclosing scope
             let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
 
             // Store as __type_params__
             let dunder_type_params = self.name("__type_params__");
-            emit!(self, Instruction::StoreName(dunder_type_params));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dunder_type_params
+                }
+            );
         }
 
         // PEP 649: Initialize __classdict__ cell for class annotation scope
         if self.current_symbol_table().needs_classdict {
             emit!(self, Instruction::LoadLocals);
             let classdict_idx = self.get_cell_var_index("__classdict__")?;
-            emit!(self, Instruction::StoreDeref(classdict_idx));
+            emit!(self, Instruction::StoreDeref { i: classdict_idx });
         }
 
         // Handle class annotations based on future_annotations flag
@@ -4534,7 +4545,7 @@ impl Compiler {
             } else {
                 // PEP 649: Initialize __conditional_annotations__ set if needed for class
                 if self.current_symbol_table().has_conditional_annotations {
-                    emit!(self, Instruction::BuildSet { size: 0 });
+                    emit!(self, Instruction::BuildSet { count: 0 });
                     self.store_name("__conditional_annotations__")?;
                 }
 
@@ -4557,10 +4568,15 @@ impl Compiler {
             .position(|var| *var == "__class__");
 
         if let Some(classcell_idx) = classcell_idx {
-            emit!(self, PseudoInstruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(
+                self,
+                PseudoInstruction::LoadClosure {
+                    i: classcell_idx.to_u32()
+                }
+            );
+            emit!(self, Instruction::Copy { i: 1 });
             let classcell = self.name("__classcell__");
-            emit!(self, Instruction::StoreName(classcell));
+            emit!(self, Instruction::StoreName { namei: classcell });
         } else {
             self.emit_load_const(ConstantData::None);
         }
@@ -4613,7 +4629,12 @@ impl Compiler {
             // Compile type parameters and store as .type_params
             self.compile_type_params(type_params.unwrap())?;
             let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::StoreName(dot_type_params));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dot_type_params
+                }
+            );
         }
 
         // Step 2: Compile class body (always done, whether generic or not)
@@ -4634,14 +4655,24 @@ impl Compiler {
             let dot_generic_base = self.name(".generic_base");
 
             // Create .generic_base
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
             emit!(
                 self,
                 Instruction::CallIntrinsic1 {
                     func: bytecode::IntrinsicFunction1::SubscriptGeneric
                 }
             );
-            emit!(self, Instruction::StoreName(dot_generic_base));
+            emit!(
+                self,
+                Instruction::StoreName {
+                    namei: dot_generic_base
+                }
+            );
 
             // Generate class creation code
             emit!(self, Instruction::LoadBuildClass);
@@ -4649,7 +4680,12 @@ impl Compiler {
 
             // Set up the class function with type params
             let mut func_flags = bytecode::MakeFunctionFlags::empty();
-            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::LoadName {
+                    namei: dot_type_params
+                }
+            );
             func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
 
             // Create class function with closure
@@ -4672,7 +4708,7 @@ impl Compiler {
                 // Need to build: args tuple = (class_func, name, *bases, .generic_base)
 
                 // Build a list starting with class_func and name (2 elements already on stack)
-                emit!(self, Instruction::BuildList { size: 2 });
+                emit!(self, Instruction::BuildList { count: 2 });
 
                 // Add bases to the list
                 if let Some(arguments) = arguments {
@@ -4690,7 +4726,12 @@ impl Compiler {
                 }
 
                 // Add .generic_base as final element
-                emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: dot_generic_base
+                    }
+                );
                 emit!(self, Instruction::ListAppend { i: 0 });
 
                 // Convert list to tuple
@@ -4721,7 +4762,12 @@ impl Compiler {
                 };
 
                 // Load .generic_base as the last base
-                emit!(self, Instruction::LoadName(dot_generic_base));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: dot_generic_base
+                    }
+                );
 
                 let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;
 
@@ -4745,13 +4791,13 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::CallKw {
-                            nargs: nargs
+                            argc: nargs
                                 + u32::try_from(arguments.keywords.len())
                                     .expect("too many keyword arguments")
                         }
                     );
                 } else {
-                    emit!(self, Instruction::Call { nargs });
+                    emit!(self, Instruction::Call { argc: nargs });
                 }
             }
 
@@ -4765,7 +4811,7 @@ impl Compiler {
             // Execute the type params function
             self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
             emit!(self, Instruction::PushNull);
-            emit!(self, Instruction::Call { nargs: 0 });
+            emit!(self, Instruction::Call { argc: 0 });
         } else {
             // Non-generic class: standard path
             emit!(self, Instruction::LoadBuildClass);
@@ -4778,7 +4824,7 @@ impl Compiler {
             if let Some(arguments) = arguments {
                 self.codegen_call_helper(2, arguments, self.current_source_range)?;
             } else {
-                emit!(self, Instruction::Call { nargs: 2 });
+                emit!(self, Instruction::Call { argc: 2 });
             }
         }
 
@@ -4810,12 +4856,7 @@ impl Compiler {
         let was_in_loop = self.ctx.loop_data.replace((while_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: while_block,
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: while_block });
         self.switch_to_block(else_block);
 
         // Pop fblock
@@ -4877,7 +4918,7 @@ impl Compiler {
         self.set_source_range(with_range);
 
         // Stack: [cm]
-        emit!(self, Instruction::Copy { index: 1_u32 }); // [cm, cm]
+        emit!(self, Instruction::Copy { i: 1 }); // [cm, cm]
 
         if is_async {
             if self.ctx.func != FunctionContext::AsyncFunction {
@@ -4890,7 +4931,7 @@ impl Compiler {
                     method: SpecialMethod::AExit
                 }
             ); // [cm, bound_aexit]
-            emit!(self, Instruction::Swap { index: 2_u32 }); // [bound_aexit, cm]
+            emit!(self, Instruction::Swap { i: 2 }); // [bound_aexit, cm]
             emit!(
                 self,
                 Instruction::LoadSpecial {
@@ -4899,8 +4940,8 @@ impl Compiler {
             ); // [bound_aexit, bound_aenter]
             // bound_aenter is already bound, call with NULL self_or_null
             emit!(self, Instruction::PushNull); // [bound_aexit, bound_aenter, NULL]
-            emit!(self, Instruction::Call { nargs: 0 }); // [bound_aexit, awaitable]
-            emit!(self, Instruction::GetAwaitable { arg: 1 });
+            emit!(self, Instruction::Call { argc: 0 }); // [bound_aexit, awaitable]
+            emit!(self, Instruction::GetAwaitable { r#where: 1 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         } else {
@@ -4911,7 +4952,7 @@ impl Compiler {
                     method: SpecialMethod::Exit
                 }
             ); // [cm, bound_exit]
-            emit!(self, Instruction::Swap { index: 2_u32 }); // [bound_exit, cm]
+            emit!(self, Instruction::Swap { i: 2 }); // [bound_exit, cm]
             emit!(
                 self,
                 Instruction::LoadSpecial {
@@ -4920,7 +4961,7 @@ impl Compiler {
             ); // [bound_exit, bound_enter]
             // bound_enter is already bound, call with NULL self_or_null
             emit!(self, Instruction::PushNull); // [bound_exit, bound_enter, NULL]
-            emit!(self, Instruction::Call { nargs: 0 }); // [bound_exit, enter_result]
+            emit!(self, Instruction::Call { argc: 0 }); // [bound_exit, enter_result]
         }
 
         // Stack: [..., __exit__, enter_result]
@@ -4929,7 +4970,7 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupWith {
-                target: exc_handler_block
+                delta: exc_handler_block
             }
         );
         self.push_fblock(
@@ -4981,19 +5022,14 @@ impl Compiler {
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
         self.emit_load_const(ConstantData::None);
-        emit!(self, Instruction::Call { nargs: 3 });
+        emit!(self, Instruction::Call { argc: 3 });
         if is_async {
-            emit!(self, Instruction::GetAwaitable { arg: 2 });
+            emit!(self, Instruction::GetAwaitable { r#where: 2 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         }
         emit!(self, Instruction::PopTop); // Pop __exit__ result
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: after_block
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
         // ===== Exception handler path =====
         // Stack at entry (after unwind): [..., __exit__, lasti, exc]
@@ -5007,7 +5043,7 @@ impl Compiler {
         emit!(
             self,
             PseudoInstruction::SetupCleanup {
-                target: cleanup_block
+                delta: cleanup_block
             }
         );
         self.push_fblock(FBlockType::ExceptionHandler, exc_handler_block, after_block)?;
@@ -5021,7 +5057,7 @@ impl Compiler {
         emit!(self, Instruction::WithExceptStart);
 
         if is_async {
-            emit!(self, Instruction::GetAwaitable { arg: 2 });
+            emit!(self, Instruction::GetAwaitable { r#where: 2 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         }
@@ -5031,7 +5067,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::PopJumpIfTrue {
-                target: suppress_block
+                delta: suppress_block
             }
         );
 
@@ -5054,12 +5090,7 @@ impl Compiler {
         emit!(self, Instruction::PopExcept); // pop exc and restore prev_exc
         emit!(self, Instruction::PopTop); // pop __exit__
         emit!(self, Instruction::PopTop); // pop lasti
-        emit!(
-            self,
-            PseudoInstruction::Jump {
-                target: after_block
-            }
-        );
+        emit!(self, PseudoInstruction::Jump { delta: after_block });
 
         // ===== Cleanup block (for nested exception during __exit__) =====
         // Stack: [..., __exit__, lasti, prev_exc, lasti2, exc2]
@@ -5072,7 +5103,7 @@ impl Compiler {
         // to be in the exception table for these instructions.
         // If we cleared fblock, exceptions here would propagate uncaught.
         self.switch_to_block(cleanup_block);
-        emit!(self, Instruction::Copy { index: 3 });
+        emit!(self, Instruction::Copy { i: 3 });
         emit!(self, Instruction::PopExcept);
         emit!(self, Instruction::Reraise { depth: 1 });
 
@@ -5114,7 +5145,7 @@ impl Compiler {
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
             // SETUP_FINALLY to guard the __anext__ call
-            emit!(self, PseudoInstruction::SetupFinally { target: else_block });
+            emit!(self, PseudoInstruction::SetupFinally { delta: else_block });
             emit!(self, Instruction::GetANext);
             self.emit_load_const(ConstantData::None);
             end_async_for_target = self.compile_yield_from_sequence(true)?;
@@ -5133,7 +5164,7 @@ impl Compiler {
             // Push fblock for for loop
             self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
 
-            emit!(self, Instruction::ForIter { target: else_block });
+            emit!(self, Instruction::ForIter { delta: else_block });
 
             // Start of loop iteration, set targets:
             self.compile_store(target)?;
@@ -5142,7 +5173,7 @@ impl Compiler {
         let was_in_loop = self.ctx.loop_data.replace((for_block, after_block));
         self.compile_statements(body)?;
         self.ctx.loop_data = was_in_loop;
-        emit!(self, PseudoInstruction::Jump { target: for_block });
+        emit!(self, PseudoInstruction::Jump { delta: for_block });
 
         self.switch_to_block(else_block);
 
@@ -5215,7 +5246,7 @@ impl Compiler {
                 emit!(
                     self,
                     PseudoInstruction::Jump {
-                        target: pc.fail_pop[pops]
+                        delta: pc.fail_pop[pops]
                     }
                 );
             }
@@ -5223,7 +5254,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: pc.fail_pop[pops]
+                        delta: pc.fail_pop[pops]
                     }
                 );
             }
@@ -5265,7 +5296,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(count).unwrap()
+                    i: u32::try_from(count).unwrap()
                 }
             );
             count -= 1;
@@ -5325,11 +5356,11 @@ impl Compiler {
                         todo!();
                         // return self.compiler_error(loc, "too many expressions in star-unpacking sequence pattern");
                     }
-                    let args = UnpackExArgs {
+                    let counts = UnpackExArgs {
                         before: u8::try_from(i).unwrap(),
                         after: u8::try_from(n - i - 1).unwrap(),
                     };
-                    emit!(self, Instruction::UnpackEx { args });
+                    emit!(self, Instruction::UnpackEx { counts });
                     seen_star = true;
                 } else {
                     // TODO: Fix error msg
@@ -5342,7 +5373,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::UnpackSequence {
-                    size: u32::try_from(n).unwrap()
+                    count: u32::try_from(n).unwrap()
                 }
             );
         }
@@ -5387,7 +5418,7 @@ impl Compiler {
                 continue;
             }
             // Duplicate the subject.
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { i: 1 });
             if i < star {
                 // For indices before the star, use a nonnegative index equal to i.
                 self.emit_load_const(ConstantData::Integer { value: i.into() });
@@ -5465,7 +5496,7 @@ impl Compiler {
 
         // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
         pc.on_top += 1;
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // Compile the sub-pattern.
         self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
         // After success, decrement the on_top counter.
@@ -5561,13 +5592,23 @@ impl Compiler {
             elements: attr_names,
         });
         // 2. Emit MATCH_CLASS with nargs.
-        emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
+        emit!(
+            self,
+            Instruction::MatchClass {
+                count: u32::try_from(nargs).unwrap()
+            }
+        );
         // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // 4. Load None.
         self.emit_load_const(ConstantData::None);
         // 5. Compare with IS_OP 1.
-        emit!(self, Instruction::IsOp(Invert::Yes));
+        emit!(
+            self,
+            Instruction::IsOp {
+                invert: Invert::Yes
+            }
+        );
 
         // At this point the TOS is a tuple of (nargs + n_attrs) attributes (or None).
         pc.on_top += 1;
@@ -5578,7 +5619,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::UnpackSequence {
-                size: u32::try_from(total).unwrap()
+                count: u32::try_from(total).unwrap()
             }
         );
         pc.on_top += total;
@@ -5663,7 +5704,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::GreaterOrEqual
+                    opname: ComparisonOperator::GreaterOrEqual
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -5719,7 +5760,7 @@ impl Compiler {
         // Stack: [subject, key1, key2, ..., key_n]
 
         // Build tuple of keys (empty tuple if size==0)
-        emit!(self, Instruction::BuildTuple { size });
+        emit!(self, Instruction::BuildTuple { count: size });
         // Stack: [subject, keys_tuple]
 
         // Match keys
@@ -5728,19 +5769,24 @@ impl Compiler {
         pc.on_top += 2; // subject and keys_tuple are underneath
 
         // Check if match succeeded
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         // Stack: [subject, keys_tuple, values_tuple, values_tuple_copy]
 
         // Check if copy is None (consumes the copy like POP_JUMP_IF_NONE)
         self.emit_load_const(ConstantData::None);
-        emit!(self, Instruction::IsOp(Invert::Yes));
+        emit!(
+            self,
+            Instruction::IsOp {
+                invert: Invert::Yes
+            }
+        );
 
         // Stack: [subject, keys_tuple, values_tuple, bool]
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         // Stack: [subject, keys_tuple, values_tuple]
 
         // Unpack values (the original values_tuple)
-        emit!(self, Instruction::UnpackSequence { size });
+        emit!(self, Instruction::UnpackSequence { count: size });
         // Stack after unpack: [subject, keys_tuple, ...unpacked values...]
         pc.on_top += size as usize; // Unpacked size values, tuple replaced by values
         pc.on_top -= 1;
@@ -5762,16 +5808,16 @@ impl Compiler {
             // Stack: [subject, keys_tuple]
 
             // Build rest dict exactly
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
             // Stack: [subject, keys_tuple, {}]
-            emit!(self, Instruction::Swap { index: 3 });
+            emit!(self, Instruction::Swap { i: 3 });
             // Stack: [{}, keys_tuple, subject]
-            emit!(self, Instruction::DictUpdate { index: 2 });
+            emit!(self, Instruction::DictUpdate { i: 2 });
             // Stack after DICT_UPDATE: [rest_dict, keys_tuple]
             // DICT_UPDATE consumes source (subject) and leaves dict in place
 
             // Unpack keys and delete from rest_dict
-            emit!(self, Instruction::UnpackSequence { size });
+            emit!(self, Instruction::UnpackSequence { count: size });
             // Stack: [rest_dict, k1, k2, ..., kn] (if size==0, nothing pushed)
 
             // Delete each key from rest_dict (skipped when size==0)
@@ -5779,14 +5825,9 @@ impl Compiler {
             let mut remaining = size;
             while remaining > 0 {
                 // Copy rest_dict which is at position (1 + remaining) from TOS
-                emit!(
-                    self,
-                    Instruction::Copy {
-                        index: 1 + remaining
-                    }
-                );
+                emit!(self, Instruction::Copy { i: 1 + remaining });
                 // Stack: [rest_dict, k1, ..., kn, rest_dict]
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap { i: 2 });
                 // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
                 emit!(self, Instruction::DeleteSubscr);
                 // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
@@ -5842,7 +5883,7 @@ impl Compiler {
             pc.fail_pop.clear();
             pc.on_top = 0;
             // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, Instruction::Copy { index: 1_u32 });
+            emit!(self, Instruction::Copy { i: 1 });
             self.compile_pattern(alt, pc)?;
 
             let n_stores = pc.stores.len();
@@ -5886,7 +5927,7 @@ impl Compiler {
                 }
             }
             // Emit a jump to the common end label and reset any failure jump targets.
-            emit!(self, PseudoInstruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { delta: end });
             self.emit_and_reset_fail_pop(pc)?;
         }
 
@@ -5971,7 +6012,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::Equal
+                    opname: ComparisonOperator::Equal
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -5984,7 +6025,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::CompareOp {
-                    op: ComparisonOperator::GreaterOrEqual
+                    opname: ComparisonOperator::GreaterOrEqual
                 }
             );
             self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
@@ -6013,7 +6054,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::CompareOp {
-                op: bytecode::ComparisonOperator::Equal
+                opname: bytecode::ComparisonOperator::Equal
             }
         );
         // emit!(self, Instruction::ToBool);
@@ -6033,7 +6074,7 @@ impl Compiler {
             ast::Singleton::True => ConstantData::Boolean { value: true },
         });
         // Compare using the "Is" operator.
-        emit!(self, Instruction::IsOp(Invert::No));
+        emit!(self, Instruction::IsOp { invert: Invert::No });
         // Jump to the failure label if the comparison is false.
         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
         Ok(())
@@ -6089,7 +6130,7 @@ impl Compiler {
         for (i, m) in cases.iter().enumerate().take(case_count) {
             // Only copy the subject if not on the last case
             if i != case_count - 1 {
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
             }
 
             pattern_context.stores = Vec::with_capacity(1);
@@ -6112,7 +6153,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::PopJumpIfFalse {
-                        target: pattern_context.fail_pop[0]
+                        delta: pattern_context.fail_pop[0]
                     }
                 );
             }
@@ -6122,7 +6163,7 @@ impl Compiler {
             }
 
             self.compile_statements(&m.body)?;
-            emit!(self, PseudoInstruction::Jump { target: end });
+            emit!(self, PseudoInstruction::Jump { delta: end });
             self.emit_and_reset_fail_pop(pattern_context)?;
         }
 
@@ -6136,8 +6177,8 @@ impl Compiler {
             if let Some(ref guard) = m.guard {
                 // Compile guard and jump to end if false
                 self.compile_expression(guard)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
-                emit!(self, Instruction::PopJumpIfFalse { target: end });
+                emit!(self, Instruction::Copy { i: 1 });
+                emit!(self, Instruction::PopJumpIfFalse { delta: end });
                 emit!(self, Instruction::PopTop);
             }
             self.compile_statements(&m.body)?;
@@ -6162,18 +6203,38 @@ impl Compiler {
     fn compile_addcompare(&mut self, op: &ast::CmpOp) {
         use bytecode::ComparisonOperator::*;
         match op {
-            ast::CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
-            ast::CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
-            ast::CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
-            ast::CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
-            ast::CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
+            ast::CmpOp::Eq => emit!(self, Instruction::CompareOp { opname: Equal }),
+            ast::CmpOp::NotEq => emit!(self, Instruction::CompareOp { opname: NotEqual }),
+            ast::CmpOp::Lt => emit!(self, Instruction::CompareOp { opname: Less }),
+            ast::CmpOp::LtE => emit!(
+                self,
+                Instruction::CompareOp {
+                    opname: LessOrEqual
+                }
+            ),
+            ast::CmpOp::Gt => emit!(self, Instruction::CompareOp { opname: Greater }),
             ast::CmpOp::GtE => {
-                emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
+                emit!(
+                    self,
+                    Instruction::CompareOp {
+                        opname: GreaterOrEqual
+                    }
+                )
             }
-            ast::CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
-            ast::CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
-            ast::CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
-            ast::CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
+            ast::CmpOp::In => emit!(self, Instruction::ContainsOp { invert: Invert::No }),
+            ast::CmpOp::NotIn => emit!(
+                self,
+                Instruction::ContainsOp {
+                    invert: Invert::Yes
+                }
+            ),
+            ast::CmpOp::Is => emit!(self, Instruction::IsOp { invert: Invert::No }),
+            ast::CmpOp::IsNot => emit!(
+                self,
+                Instruction::IsOp {
+                    invert: Invert::Yes
+                }
+            ),
         }
     }
 
@@ -6225,14 +6286,14 @@ impl Compiler {
 
             // store rhs for the next comparison in chain
             self.set_source_range(compare_range);
-            emit!(self, Instruction::Swap { index: 2 });
-            emit!(self, Instruction::Copy { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
+            emit!(self, Instruction::Copy { i: 2 });
 
             self.compile_addcompare(op);
 
             // if comparison result is false, we break with this value; if true, try the next one.
-            emit!(self, Instruction::Copy { index: 1 });
-            emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
+            emit!(self, Instruction::Copy { i: 1 });
+            emit!(self, Instruction::PopJumpIfFalse { delta: cleanup });
             emit!(self, Instruction::PopTop);
         }
 
@@ -6241,11 +6302,11 @@ impl Compiler {
         self.compile_addcompare(last_op);
 
         let end = self.new_block();
-        emit!(self, PseudoInstruction::Jump { target: end });
+        emit!(self, PseudoInstruction::Jump { delta: end });
 
         // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
         self.switch_to_block(cleanup);
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { i: 2 });
         emit!(self, Instruction::PopTop);
 
         self.switch_to_block(end);
@@ -6269,7 +6330,7 @@ impl Compiler {
                     // *args: *Ts (where Ts is a TypeVarTuple).
                     // Do [annotation_value] = [*Ts].
                     self.compile_expression(value)?;
-                    emit!(self, Instruction::UnpackSequence { size: 1 });
+                    emit!(self, Instruction::UnpackSequence { count: 1 });
                     Ok(())
                 }
                 _ => self.compile_expression(annotation),
@@ -6305,7 +6366,12 @@ impl Compiler {
                 self.compile_annotation(annotation)?;
                 // Load __annotations__
                 let annotations_name = self.name("__annotations__");
-                emit!(self, Instruction::LoadName(annotations_name));
+                emit!(
+                    self,
+                    Instruction::LoadName {
+                        namei: annotations_name
+                    }
+                );
                 // Load the variable name
                 self.emit_load_const(ConstantData::Str {
                     value: self.mangle(id.as_str()).into_owned().into(),
@@ -6335,7 +6401,7 @@ impl Compiler {
                         self.emit_load_const(ConstantData::Integer {
                             value: annotation_index.into(),
                         });
-                        emit!(self, Instruction::SetAdd { i: 0_u32 });
+                        emit!(self, Instruction::SetAdd { i: 0 });
                         emit!(self, Instruction::PopTop);
                     }
                 }
@@ -6355,8 +6421,8 @@ impl Compiler {
             }
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::StoreAttr { idx });
+                let namei = self.name(attr.as_str());
+                emit!(self, Instruction::StoreAttr { namei });
             }
             ast::Expr::List(ast::ExprList { elts, .. })
             | ast::Expr::Tuple(ast::ExprTuple { elts, .. }) => {
@@ -6378,8 +6444,8 @@ impl Compiler {
                                         target.range(),
                                     )
                                 })?;
-                            let args = bytecode::UnpackExArgs { before, after };
-                            emit!(self, Instruction::UnpackEx { args });
+                            let counts = bytecode::UnpackExArgs { before, after };
+                            emit!(self, Instruction::UnpackEx { counts });
                         }
                     }
                 }
@@ -6388,7 +6454,7 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::UnpackSequence {
-                            size: elts.len().to_u32(),
+                            count: elts.len().to_u32(),
                         }
                     );
                 }
@@ -6442,8 +6508,8 @@ impl Compiler {
                 // But we can't use compile_subscript directly because we need DUP_TOP2
                 self.compile_expression(value)?;
                 self.compile_expression(slice)?;
-                emit!(self, Instruction::Copy { index: 2_u32 });
-                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::Copy { i: 2 });
+                emit!(self, Instruction::Copy { i: 2 });
                 emit!(
                     self,
                     Instruction::BinaryOp {
@@ -6455,7 +6521,7 @@ impl Compiler {
             ast::Expr::Attribute(ast::ExprAttribute { value, attr, .. }) => {
                 let attr = attr.as_str();
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 let idx = self.name(attr);
                 self.emit_load_attr(idx);
                 AugAssignKind::Attr { idx }
@@ -6475,14 +6541,14 @@ impl Compiler {
             }
             AugAssignKind::Subscript => {
                 // stack: CONTAINER SLICE RESULT
-                emit!(self, Instruction::Swap { index: 3 });
-                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::Swap { i: 3 });
+                emit!(self, Instruction::Swap { i: 2 });
                 emit!(self, Instruction::StoreSubscr);
             }
             AugAssignKind::Attr { idx } => {
                 // stack: CONTAINER RESULT
-                emit!(self, Instruction::Swap { index: 2 });
-                emit!(self, Instruction::StoreAttr { idx });
+                emit!(self, Instruction::Swap { i: 2 });
+                emit!(self, Instruction::StoreAttr { namei: idx });
             }
         }
 
@@ -6586,14 +6652,14 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::PopJumpIfTrue {
-                            target: target_block,
+                            delta: target_block,
                         }
                     );
                 } else {
                     emit!(
                         self,
                         Instruction::PopJumpIfFalse {
-                            target: target_block,
+                            delta: target_block,
                         }
                     );
                 }
@@ -6656,13 +6722,13 @@ impl Compiler {
     /// Emit `Copy 1` + conditional jump for short-circuit evaluation.
     /// For `And`, emits `PopJumpIfFalse`; for `Or`, emits `PopJumpIfTrue`.
     fn emit_short_circuit_test(&mut self, op: &ast::BoolOp, target: BlockIdx) {
-        emit!(self, Instruction::Copy { index: 1_u32 });
+        emit!(self, Instruction::Copy { i: 1 });
         match op {
             ast::BoolOp::And => {
-                emit!(self, Instruction::PopJumpIfFalse { target });
+                emit!(self, Instruction::PopJumpIfFalse { delta: target });
             }
             ast::BoolOp::Or => {
-                emit!(self, Instruction::PopJumpIfTrue { target });
+                emit!(self, Instruction::PopJumpIfTrue { delta: target });
             }
         }
     }
@@ -6679,7 +6745,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildMap {
-                    size: u32::try_from(items.len()).expect("too many dict items"),
+                    count: u32::try_from(items.len()).expect("too many dict items"),
                 }
             );
             return Ok(());
@@ -6697,9 +6763,9 @@ impl Compiler {
             () => {
                 #[allow(unused_assignments)]
                 if elements > 0 {
-                    emit!(self, Instruction::BuildMap { size: elements });
+                    emit!(self, Instruction::BuildMap { count: elements });
                     if have_dict {
-                        emit!(self, Instruction::DictUpdate { index: 1 });
+                        emit!(self, Instruction::DictUpdate { i: 1 });
                     } else {
                         have_dict = true;
                     }
@@ -6718,17 +6784,17 @@ impl Compiler {
                 // ** unpacking entry
                 flush_pending!();
                 if !have_dict {
-                    emit!(self, Instruction::BuildMap { size: 0 });
+                    emit!(self, Instruction::BuildMap { count: 0 });
                     have_dict = true;
                 }
                 self.compile_expression(&item.value)?;
-                emit!(self, Instruction::DictUpdate { index: 1 });
+                emit!(self, Instruction::DictUpdate { i: 1 });
             }
         }
 
         flush_pending!();
         if !have_dict {
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
         }
 
         Ok(())
@@ -6755,10 +6821,10 @@ impl Compiler {
 
         // send:
         self.switch_to_block(send_block);
-        emit!(self, Instruction::Send { target: exit_block });
+        emit!(self, Instruction::Send { delta: exit_block });
 
         // SETUP_FINALLY fail - set up exception handler for YIELD_VALUE
-        emit!(self, PseudoInstruction::SetupFinally { target: fail_block });
+        emit!(self, PseudoInstruction::SetupFinally { delta: fail_block });
         self.push_fblock(
             FBlockType::TryExcept, // Use TryExcept for exception handler
             send_block,
@@ -6776,7 +6842,7 @@ impl Compiler {
         emit!(
             self,
             Instruction::Resume {
-                arg: if is_await {
+                context: if is_await {
                     u32::from(bytecode::ResumeType::AfterAwait)
                 } else {
                     u32::from(bytecode::ResumeType::AfterYieldFrom)
@@ -6787,7 +6853,7 @@ impl Compiler {
         // JUMP_BACKWARD_NO_INTERRUPT send
         emit!(
             self,
-            PseudoInstruction::JumpNoInterrupt { target: send_block }
+            PseudoInstruction::JumpNoInterrupt { delta: send_block }
         );
 
         // fail: CLEANUP_THROW
@@ -6938,7 +7004,7 @@ impl Compiler {
                 emit!(
                     self,
                     Instruction::Resume {
-                        arg: u32::from(bytecode::ResumeType::AfterYield)
+                        context: u32::from(bytecode::ResumeType::AfterYield)
                     }
                 );
             }
@@ -6947,7 +7013,7 @@ impl Compiler {
                     return Err(self.error(CodegenErrorType::InvalidAwait));
                 }
                 self.compile_expression(value)?;
-                emit!(self, Instruction::GetAwaitable { arg: 0 });
+                emit!(self, Instruction::GetAwaitable { r#where: 0 });
                 self.emit_load_const(ConstantData::None);
                 let _ = self.compile_yield_from_sequence(true)?;
             }
@@ -6991,7 +7057,7 @@ impl Compiler {
                     for element in &defaults {
                         self.compile_expression(element)?;
                     }
-                    emit!(self, Instruction::BuildTuple { size });
+                    emit!(self, Instruction::BuildTuple { count: size });
                 }
 
                 // Prepare keyword-only defaults
@@ -7014,7 +7080,7 @@ impl Compiler {
                     emit!(
                         self,
                         Instruction::BuildMap {
-                            size: default_kw_count.to_u32(),
+                            count: default_kw_count.to_u32(),
                         }
                     );
                 }
@@ -7057,7 +7123,7 @@ impl Compiler {
                     "<listcomp>",
                     Some(
                         Instruction::BuildList {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -7083,7 +7149,7 @@ impl Compiler {
                     "<setcomp>",
                     Some(
                         Instruction::BuildSet {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -7112,7 +7178,7 @@ impl Compiler {
                     "<dictcomp>",
                     Some(
                         Instruction::BuildMap {
-                            size: OpArgMarker::marker(),
+                            count: OpArgMarker::marker(),
                         }
                         .into(),
                     ),
@@ -7160,7 +7226,7 @@ impl Compiler {
                         emit!(
                             compiler,
                             Instruction::Resume {
-                                arg: u32::from(bytecode::ResumeType::AfterYield)
+                                context: u32::from(bytecode::ResumeType::AfterYield)
                             }
                         );
                         emit!(compiler, Instruction::PopTop);
@@ -7190,12 +7256,7 @@ impl Compiler {
 
                 // True case
                 self.compile_expression(body)?;
-                emit!(
-                    self,
-                    PseudoInstruction::Jump {
-                        target: after_block,
-                    }
-                );
+                emit!(self, PseudoInstruction::Jump { delta: after_block });
 
                 // False case
                 self.switch_to_block(else_block);
@@ -7212,7 +7273,7 @@ impl Compiler {
                 range: _,
             }) => {
                 self.compile_expression(value)?;
-                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(self, Instruction::Copy { i: 1 });
                 self.compile_store(target)?;
             }
             ast::Expr::FString(fstring) => {
@@ -7295,14 +7356,14 @@ impl Compiler {
                         sub_size += 1;
                     }
                 }
-                emit!(self, Instruction::BuildMap { size: sub_size });
+                emit!(self, Instruction::BuildMap { count: sub_size });
                 size += 1;
             }
         }
         if size > 1 {
             // Merge all dicts: first dict is accumulator, merge rest into it
             for _ in 1..size {
-                emit!(self, Instruction::DictMerge { index: 1 });
+                emit!(self, Instruction::DictMerge { i: 1 });
             }
         }
         Ok(())
@@ -7371,7 +7432,7 @@ impl Compiler {
         let big = n * 2 > 8; // STACK_USE_GUIDELINE approximation
 
         if big {
-            emit!(self, Instruction::BuildMap { size: 0 });
+            emit!(self, Instruction::BuildMap { count: 0 });
         }
 
         for kw in &keywords[begin..end] {
@@ -7387,7 +7448,7 @@ impl Compiler {
         }
 
         if !big {
-            emit!(self, Instruction::BuildMap { size: n.to_u32() });
+            emit!(self, Instruction::BuildMap { count: n.to_u32() });
         }
 
         Ok(())
@@ -7437,12 +7498,12 @@ impl Compiler {
                     elements: kwarg_names,
                 });
 
-                let nargs = additional_positional + nelts.to_u32() + nkwelts.to_u32();
-                emit!(self, Instruction::CallKw { nargs });
+                let argc = additional_positional + nelts.to_u32() + nkwelts.to_u32();
+                emit!(self, Instruction::CallKw { argc });
             } else {
                 self.set_source_range(call_range);
-                let nargs = additional_positional + nelts.to_u32();
-                emit!(self, Instruction::Call { nargs });
+                let argc = additional_positional + nelts.to_u32();
+                emit!(self, Instruction::Call { argc });
             }
         } else {
             // ex_call path: has * or ** args
@@ -7484,19 +7545,19 @@ impl Compiler {
                             // Pack up preceding keywords using codegen_subkwargs
                             self.codegen_subkwargs(&arguments.keywords, i - nseen, i)?;
                             if have_dict {
-                                emit!(self, Instruction::DictMerge { index: 1 });
+                                emit!(self, Instruction::DictMerge { i: 1 });
                             }
                             have_dict = true;
                             nseen = 0;
                         }
 
                         if !have_dict {
-                            emit!(self, Instruction::BuildMap { size: 0 });
+                            emit!(self, Instruction::BuildMap { count: 0 });
                             have_dict = true;
                         }
 
                         self.compile_expression(&keyword.value)?;
-                        emit!(self, Instruction::DictMerge { index: 1 });
+                        emit!(self, Instruction::DictMerge { i: 1 });
                     } else {
                         nseen += 1;
                     }
@@ -7506,7 +7567,7 @@ impl Compiler {
                 if nseen > 0 {
                     self.codegen_subkwargs(&arguments.keywords, nkwelts - nseen, nkwelts)?;
                     if have_dict {
-                        emit!(self, Instruction::DictMerge { index: 1 });
+                        emit!(self, Instruction::DictMerge { i: 1 });
                     }
                     have_dict = true;
                 }
@@ -7633,7 +7694,7 @@ impl Compiler {
 
             if loop_labels.is_empty() {
                 // Load iterator onto stack (passed as first argument):
-                emit!(self, Instruction::LoadFast(arg0));
+                emit!(self, Instruction::LoadFast { var_num: arg0 });
             } else {
                 // Evaluate iterated item:
                 self.compile_expression(&generator.iter)?;
@@ -7649,12 +7710,7 @@ impl Compiler {
             self.switch_to_block(loop_block);
             let mut end_async_for_target = BlockIdx::NULL;
             if generator.is_async {
-                emit!(
-                    self,
-                    PseudoInstruction::SetupFinally {
-                        target: after_block
-                    }
-                );
+                emit!(self, PseudoInstruction::SetupFinally { delta: after_block });
                 emit!(self, Instruction::GetANext);
                 self.push_fblock(
                     FBlockType::AsyncComprehensionGenerator,
@@ -7669,12 +7725,7 @@ impl Compiler {
                 self.pop_fblock(FBlockType::AsyncComprehensionGenerator);
                 self.compile_store(&generator.target)?;
             } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::ForIter { delta: after_block });
                 self.compile_store(&generator.target)?;
             }
             loop_labels.push((
@@ -7696,10 +7747,10 @@ impl Compiler {
         for (loop_block, if_cleanup_block, after_block, is_async, end_async_for_target) in
             loop_labels.iter().rev().copied()
         {
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(if_cleanup_block);
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(after_block);
             if is_async {
@@ -7739,9 +7790,9 @@ impl Compiler {
         };
 
         // Call just created <listcomp> function:
-        emit!(self, Instruction::Call { nargs: 1 });
+        emit!(self, Instruction::Call { argc: 1 });
         if is_async_list_set_dict_comprehension {
-            emit!(self, Instruction::GetAwaitable { arg: 0 });
+            emit!(self, Instruction::GetAwaitable { r#where: 0 });
             self.emit_load_const(ConstantData::None);
             let _ = self.compile_yield_from_sequence(true)?;
         }
@@ -7814,8 +7865,8 @@ impl Compiler {
 
         // Step 2: Save local variables that will be shadowed by the comprehension
         for name in &pushed_locals {
-            let idx = self.varname(name)?;
-            emit!(self, Instruction::LoadFastAndClear(idx));
+            let var_num = self.varname(name)?;
+            emit!(self, Instruction::LoadFastAndClear { var_num });
         }
 
         // Step 3: SWAP iterator to TOS (above saved locals)
@@ -7823,7 +7874,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
         }
@@ -7833,7 +7884,7 @@ impl Compiler {
         if let Some(init_collection) = init_collection {
             self._emit(init_collection, OpArg::new(0), BlockIdx::NULL);
             // SWAP to get iterator on top
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
         }
 
         // Set up exception handler for cleanup on exception
@@ -7844,7 +7895,7 @@ impl Compiler {
             emit!(
                 self,
                 PseudoInstruction::SetupFinally {
-                    target: cleanup_block
+                    delta: cleanup_block
                 }
             );
             self.push_fblock(FBlockType::TryExcept, cleanup_block, end_block)?;
@@ -7876,12 +7927,7 @@ impl Compiler {
                 end_async_for_target = self.compile_yield_from_sequence(true)?;
                 self.compile_store(&generator.target)?;
             } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
+                emit!(self, Instruction::ForIter { delta: after_block });
                 self.compile_store(&generator.target)?;
             }
             loop_labels.push((
@@ -7905,10 +7951,10 @@ impl Compiler {
         for (loop_block, if_cleanup_block, after_block, is_async, end_async_for_target) in
             loop_labels.iter().rev().copied()
         {
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(if_cleanup_block);
-            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            emit!(self, PseudoInstruction::Jump { delta: loop_block });
 
             self.switch_to_block(after_block);
             if is_async {
@@ -7928,25 +7974,25 @@ impl Compiler {
             self.pop_fblock(FBlockType::TryExcept);
 
             // Normal path: jump past cleanup
-            emit!(self, PseudoInstruction::Jump { target: end_block });
+            emit!(self, PseudoInstruction::Jump { delta: end_block });
 
             // Exception cleanup path
             self.switch_to_block(cleanup_block);
             // Stack: [saved_locals..., collection, exception]
             // Swap to get collection out from under exception
-            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Swap { i: 2 });
             emit!(self, Instruction::PopTop); // Pop incomplete collection
 
             // Restore locals
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
             for name in pushed_locals.iter().rev() {
-                let idx = self.varname(name)?;
-                emit!(self, Instruction::StoreFast(idx));
+                let var_num = self.varname(name)?;
+                emit!(self, Instruction::StoreFast { var_num });
             }
             // Re-raise the exception
             emit!(self, Instruction::Reraise { depth: 0 });
@@ -7960,15 +8006,15 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::Swap {
-                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                    i: u32::try_from(pushed_locals.len() + 1).unwrap()
                 }
             );
         }
 
         // Restore saved locals
         for name in pushed_locals.iter().rev() {
-            let idx = self.varname(name)?;
-            emit!(self, Instruction::StoreFast(idx));
+            let var_num = self.varname(name)?;
+            emit!(self, Instruction::StoreFast { var_num });
         }
 
         Ok(())
@@ -8036,7 +8082,7 @@ impl Compiler {
 
     fn emit_load_const(&mut self, constant: ConstantData) {
         let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::LoadConst { idx })
+        self.emit_arg(idx, |consti| Instruction::LoadConst { consti })
     }
 
     fn emit_return_const(&mut self, constant: ConstantData) {
@@ -8055,7 +8101,7 @@ impl Compiler {
             .name_idx(name_idx)
             .is_method(false)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadAttr { idx: arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadAttr { namei })
     }
 
     /// Emit LOAD_ATTR with method flag set (for method calls).
@@ -8065,14 +8111,14 @@ impl Compiler {
             .name_idx(name_idx)
             .is_method(true)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadAttr { idx: arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadAttr { namei })
     }
 
     /// Emit LOAD_GLOBAL.
     /// Encodes: (name_idx << 1) | push_null_bit
     fn emit_load_global(&mut self, name_idx: u32, push_null: bool) {
         let encoded = (name_idx << 1) | u32::from(push_null);
-        self.emit_arg(encoded, Instruction::LoadGlobal);
+        self.emit_arg(encoded, |namei| Instruction::LoadGlobal { namei });
     }
 
     /// Emit LOAD_SUPER_ATTR for 2-arg super().attr access.
@@ -8083,7 +8129,7 @@ impl Compiler {
             .is_load_method(false)
             .has_class(true)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 2-arg super().method() call.
@@ -8094,7 +8140,7 @@ impl Compiler {
             .is_load_method(true)
             .has_class(true)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 0-arg super().attr access.
@@ -8105,7 +8151,7 @@ impl Compiler {
             .is_load_method(false)
             .has_class(false)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     /// Emit LOAD_SUPER_ATTR for 0-arg super().method() call.
@@ -8116,7 +8162,7 @@ impl Compiler {
             .is_load_method(true)
             .has_class(false)
             .build();
-        self.emit_arg(encoded, |arg| Instruction::LoadSuperAttr { arg })
+        self.emit_arg(encoded, |namei| Instruction::LoadSuperAttr { namei })
     }
 
     fn emit_return_value(&mut self) {
@@ -8262,10 +8308,10 @@ impl Compiler {
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
                     self.emit_load_const(ConstantData::None);
-                    emit!(self, Instruction::Call { nargs: 3 });
+                    emit!(self, Instruction::Call { argc: 3 });
 
                     if is_async {
-                        emit!(self, Instruction::GetAwaitable { arg: 2 });
+                        emit!(self, Instruction::GetAwaitable { r#where: 2 });
                         self.emit_load_const(ConstantData::None);
                         let _ = self.compile_yield_from_sequence(true)?;
                     }
@@ -8328,7 +8374,7 @@ impl Compiler {
 
         // Jump to target
         let target = if is_break { exit_block } else { loop_block };
-        emit!(self, PseudoInstruction::Jump { target });
+        emit!(self, PseudoInstruction::Jump { delta: target });
 
         Ok(())
     }
@@ -8447,7 +8493,7 @@ impl Compiler {
             .try_into()
             .expect("BuildString size overflowed");
         if part_count > 1 {
-            emit!(self, Instruction::BuildString { size: part_count });
+            emit!(self, Instruction::BuildString { count: part_count });
         }
 
         Ok(())
@@ -8570,7 +8616,7 @@ impl Compiler {
             emit!(
                 self,
                 Instruction::BuildString {
-                    size: element_count
+                    count: element_count
                 }
             );
         }
@@ -8604,7 +8650,12 @@ impl Compiler {
         // Stack currently has all interpolations from compile_tstring_into calls
 
         // 1. Build interpolations tuple from the interpolations on the stack
-        emit!(self, Instruction::BuildTuple { size: interp_count });
+        emit!(
+            self,
+            Instruction::BuildTuple {
+                count: interp_count
+            }
+        );
 
         // 2. Load all string parts
         let string_count: u32 = all_strings
@@ -8616,10 +8667,15 @@ impl Compiler {
         }
 
         // 3. Build strings tuple
-        emit!(self, Instruction::BuildTuple { size: string_count });
+        emit!(
+            self,
+            Instruction::BuildTuple {
+                count: string_count
+            }
+        );
 
         // 4. Swap so strings is below interpolations: [interps, strings] -> [strings, interps]
-        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::Swap { i: 2 });
 
         // 5. Build the Template
         emit!(self, Instruction::BuildTemplate);
@@ -8685,8 +8741,8 @@ impl Compiler {
 
                     // Emit BUILD_INTERPOLATION
                     // oparg encoding: (conversion << 2) | has_format_spec
-                    let oparg = (conversion << 2) | u32::from(has_format_spec);
-                    emit!(self, Instruction::BuildInterpolation { oparg });
+                    let format = (conversion << 2) | u32::from(has_format_spec);
+                    emit!(self, Instruction::BuildInterpolation { format });
 
                     *interp_count += 1;
                 }
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
index b21af84a51c..43a2dfa5107 100644
--- a/crates/codegen/src/ir.rs
+++ b/crates/codegen/src/ir.rs
@@ -387,19 +387,19 @@ impl CodeInfo {
                         op = match op {
                             Instruction::JumpForward { .. } if target_offset <= current_offset => {
                                 Instruction::JumpBackward {
-                                    target: Arg::marker(),
+                                    delta: Arg::marker(),
                                 }
                             }
                             Instruction::JumpBackward { .. } if target_offset > current_offset => {
                                 Instruction::JumpForward {
-                                    target: Arg::marker(),
+                                    delta: Arg::marker(),
                                 }
                             }
                             Instruction::JumpBackwardNoInterrupt { .. }
                                 if target_offset > current_offset =>
                             {
                                 Instruction::JumpForward {
-                                    target: Arg::marker(),
+                                    delta: Arg::marker(),
                                 }
                             }
                             _ => op,
@@ -632,7 +632,10 @@ impl CodeInfo {
                 }
 
                 // Replace BUILD_TUPLE with LOAD_CONST
-                block.instructions[i].instr = Instruction::LoadConst { idx: Arg::marker() }.into();
+                block.instructions[i].instr = Instruction::LoadConst {
+                    consti: Arg::marker(),
+                }
+                .into();
                 block.instructions[i].arg = OpArg::new(const_idx as u32);
 
                 i += 1;
@@ -659,13 +662,15 @@ impl CodeInfo {
 
                     match (curr_instr, next_instr) {
                         // LoadFast + LoadFast -> LoadFastLoadFast (if both indices < 16)
-                        (Instruction::LoadFast(_), Instruction::LoadFast(_)) => {
+                        (Instruction::LoadFast { .. }, Instruction::LoadFast { .. }) => {
                             let idx1 = u32::from(curr.arg);
                             let idx2 = u32::from(next.arg);
                             if idx1 < 16 && idx2 < 16 {
                                 let packed = (idx1 << 4) | idx2;
                                 Some((
-                                    Instruction::LoadFastLoadFast { arg: Arg::marker() },
+                                    Instruction::LoadFastLoadFast {
+                                        var_nums: Arg::marker(),
+                                    },
                                     OpArg::new(packed),
                                 ))
                             } else {
@@ -673,13 +678,15 @@ impl CodeInfo {
                             }
                         }
                         // StoreFast + StoreFast -> StoreFastStoreFast (if both indices < 16)
-                        (Instruction::StoreFast(_), Instruction::StoreFast(_)) => {
+                        (Instruction::StoreFast { .. }, Instruction::StoreFast { .. }) => {
                             let idx1 = u32::from(curr.arg);
                             let idx2 = u32::from(next.arg);
                             if idx1 < 16 && idx2 < 16 {
                                 let packed = (idx1 << 4) | idx2;
                                 Some((
-                                    Instruction::StoreFastStoreFast { arg: Arg::marker() },
+                                    Instruction::StoreFastStoreFast {
+                                        var_nums: Arg::marker(),
+                                    },
                                     OpArg::new(packed),
                                 ))
                             } else {
@@ -712,7 +719,7 @@ impl CodeInfo {
                 let curr = &block.instructions[i];
                 let next = &block.instructions[i + 1];
 
-                let (Some(Instruction::LoadGlobal(_)), Some(Instruction::PushNull)) =
+                let (Some(Instruction::LoadGlobal { .. }), Some(Instruction::PushNull)) =
                     (curr.instr.real(), next.instr.real())
                 else {
                     i += 1;
@@ -755,7 +762,7 @@ impl CodeInfo {
                 // Check if it's in small int range: -5 to 256 (_PY_IS_SMALL_INT)
                 if let Some(small) = value.to_i32().filter(|v| (-5..=256).contains(v)) {
                     // Convert LOAD_CONST to LOAD_SMALL_INT
-                    instr.instr = Instruction::LoadSmallInt { idx: Arg::marker() }.into();
+                    instr.instr = Instruction::LoadSmallInt { i: Arg::marker() }.into();
                     // The arg is the i32 value stored as u32 (two's complement)
                     instr.arg = OpArg::new(small as u32);
                 }
@@ -895,7 +902,7 @@ impl CodeInfo {
 
                 // Push values to stack with source instruction index
                 let source = match instr {
-                    Instruction::LoadFast(_) | Instruction::LoadFastLoadFast { .. } => i,
+                    Instruction::LoadFast { .. } | Instruction::LoadFastLoadFast { .. } => i,
                     _ => NOT_LOCAL,
                 };
                 for _ in 0..pushes {
@@ -923,12 +930,17 @@ impl CodeInfo {
                     continue;
                 };
                 match instr {
-                    Instruction::LoadFast(_) => {
-                        info.instr = Instruction::LoadFastBorrow(Arg::marker()).into();
+                    Instruction::LoadFast { .. } => {
+                        info.instr = Instruction::LoadFastBorrow {
+                            var_num: Arg::marker(),
+                        }
+                        .into();
                     }
                     Instruction::LoadFastLoadFast { .. } => {
-                        info.instr =
-                            Instruction::LoadFastBorrowLoadFastBorrow { arg: Arg::marker() }.into();
+                        info.instr = Instruction::LoadFastBorrowLoadFastBorrow {
+                            var_nums: Arg::marker(),
+                        }
+                        .into();
                     }
                     _ => {}
                 }
@@ -1415,7 +1427,7 @@ fn push_cold_blocks_to_end(blocks: &mut Vec<Block>) {
         };
         jump_block.instructions.push(InstructionInfo {
             instr: PseudoInstruction::JumpNoInterrupt {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             }
             .into(),
             arg: OpArg::new(0),
@@ -1566,12 +1578,12 @@ fn normalize_jumps(blocks: &mut [Block]) {
                 AnyInstruction::Pseudo(PseudoInstruction::Jump { .. }) => {
                     if target_pos > source_pos {
                         Instruction::JumpForward {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     } else {
                         Instruction::JumpBackward {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     }
@@ -1579,12 +1591,12 @@ fn normalize_jumps(blocks: &mut [Block]) {
                 AnyInstruction::Pseudo(PseudoInstruction::JumpNoInterrupt { .. }) => {
                     if target_pos > source_pos {
                         Instruction::JumpForward {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     } else {
                         Instruction::JumpBackwardNoInterrupt {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         }
                         .into()
                     }
@@ -1750,10 +1762,13 @@ pub(crate) fn convert_pseudo_ops(blocks: &mut [Block], varnames_len: u32) {
                     info.instr = Instruction::Nop.into();
                 }
                 // LOAD_CLOSURE → LOAD_FAST (with varnames offset)
-                PseudoInstruction::LoadClosure(idx) => {
-                    let new_idx = varnames_len + idx.get(info.arg);
+                PseudoInstruction::LoadClosure { i } => {
+                    let new_idx = varnames_len + i.get(info.arg);
                     info.arg = OpArg::new(new_idx);
-                    info.instr = Instruction::LoadFast(Arg::marker()).into();
+                    info.instr = Instruction::LoadFast {
+                        var_num: Arg::marker(),
+                    }
+                    .into();
                 }
                 // Jump pseudo ops are resolved during block linearization
                 PseudoInstruction::Jump { .. } | PseudoInstruction::JumpNoInterrupt { .. } => {}
@@ -1761,7 +1776,7 @@ pub(crate) fn convert_pseudo_ops(blocks: &mut [Block], varnames_len: u32) {
                 PseudoInstruction::AnnotationsPlaceholder
                 | PseudoInstruction::JumpIfFalse { .. }
                 | PseudoInstruction::JumpIfTrue { .. }
-                | PseudoInstruction::StoreFastMaybeNull(_) => {
+                | PseudoInstruction::StoreFastMaybeNull { .. } => {
                     unreachable!("Unexpected pseudo instruction in convert_pseudo_ops: {pseudo:?}")
                 }
             }
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
index e7b13ff21d2..754447956fa 100644
--- a/crates/compiler-core/src/bytecode/instruction.rs
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -79,28 +79,28 @@ pub enum Instruction {
     ///
     /// Stack: [value, expression_str, format_spec?] -> [interpolation]
     BuildInterpolation {
-        oparg: Arg<u32>,
+        format: Arg<u32>,
     } = 45,
     BuildList {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 46,
     BuildMap {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 47,
     BuildSet {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 48,
     BuildSlice {
         argc: Arg<BuildSliceArgCount>,
     } = 49,
     BuildString {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 50,
     BuildTuple {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 51,
     Call {
-        nargs: Arg<u32>,
+        argc: Arg<u32>,
     } = 52,
     CallIntrinsic1 {
         func: Arg<IntrinsicFunction1>,
@@ -109,57 +109,69 @@ pub enum Instruction {
         func: Arg<IntrinsicFunction2>,
     } = 54,
     CallKw {
-        nargs: Arg<u32>,
+        argc: Arg<u32>,
     } = 55,
     CompareOp {
-        op: Arg<ComparisonOperator>,
+        opname: Arg<ComparisonOperator>,
     } = 56,
-    ContainsOp(Arg<Invert>) = 57,
+    ContainsOp {
+        invert: Arg<Invert>,
+    } = 57,
     ConvertValue {
         oparg: Arg<ConvertValueOparg>,
     } = 58,
     Copy {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 59,
     CopyFreeVars {
-        count: Arg<u32>,
+        n: Arg<u32>,
     } = 60,
     DeleteAttr {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 61,
-    DeleteDeref(Arg<NameIdx>) = 62,
-    DeleteFast(Arg<NameIdx>) = 63,
-    DeleteGlobal(Arg<NameIdx>) = 64,
-    DeleteName(Arg<NameIdx>) = 65,
+    DeleteDeref {
+        i: Arg<NameIdx>,
+    } = 62,
+    DeleteFast {
+        var_num: Arg<NameIdx>,
+    } = 63,
+    DeleteGlobal {
+        namei: Arg<NameIdx>,
+    } = 64,
+    DeleteName {
+        namei: Arg<NameIdx>,
+    } = 65,
     DictMerge {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 66,
     DictUpdate {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 67,
     EndAsyncFor = 68,
     ExtendedArg = 69,
     ForIter {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 70,
     GetAwaitable {
-        arg: Arg<u32>,
+        r#where: Arg<u32>,
     } = 71,
     ImportFrom {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 72,
     ImportName {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 73,
-    IsOp(Arg<Invert>) = 74,
+    IsOp {
+        invert: Arg<Invert>,
+    } = 74,
     JumpBackward {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 75,
     JumpBackwardNoInterrupt {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 76, // Placeholder
     JumpForward {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 77,
     ListAppend {
         i: Arg<u32>,
@@ -168,101 +180,131 @@ pub enum Instruction {
         i: Arg<u32>,
     } = 79,
     LoadAttr {
-        idx: Arg<LoadAttr>,
+        namei: Arg<LoadAttr>,
     } = 80,
     LoadCommonConstant {
         idx: Arg<CommonConstant>,
     } = 81,
     LoadConst {
-        idx: Arg<u32>,
+        consti: Arg<u32>,
     } = 82,
-    LoadDeref(Arg<NameIdx>) = 83,
-    LoadFast(Arg<NameIdx>) = 84,
-    LoadFastAndClear(Arg<NameIdx>) = 85,
-    LoadFastBorrow(Arg<NameIdx>) = 86,
+    LoadDeref {
+        i: Arg<NameIdx>,
+    } = 83,
+    LoadFast {
+        var_num: Arg<NameIdx>,
+    } = 84,
+    LoadFastAndClear {
+        var_num: Arg<NameIdx>,
+    } = 85,
+    LoadFastBorrow {
+        var_num: Arg<NameIdx>,
+    } = 86,
     LoadFastBorrowLoadFastBorrow {
-        arg: Arg<u32>,
+        var_nums: Arg<u32>,
     } = 87,
-    LoadFastCheck(Arg<NameIdx>) = 88,
+    LoadFastCheck {
+        var_num: Arg<NameIdx>,
+    } = 88,
     LoadFastLoadFast {
-        arg: Arg<u32>,
+        var_nums: Arg<u32>,
     } = 89,
-    LoadFromDictOrDeref(Arg<NameIdx>) = 90,
-    LoadFromDictOrGlobals(Arg<NameIdx>) = 91,
-    LoadGlobal(Arg<NameIdx>) = 92,
-    LoadName(Arg<NameIdx>) = 93,
+    LoadFromDictOrDeref {
+        i: Arg<NameIdx>,
+    } = 90,
+    LoadFromDictOrGlobals {
+        i: Arg<NameIdx>,
+    } = 91,
+    LoadGlobal {
+        namei: Arg<NameIdx>,
+    } = 92,
+    LoadName {
+        namei: Arg<NameIdx>,
+    } = 93,
     LoadSmallInt {
-        idx: Arg<u32>,
+        i: Arg<u32>,
     } = 94,
     LoadSpecial {
         method: Arg<SpecialMethod>,
     } = 95,
     LoadSuperAttr {
-        arg: Arg<LoadSuperAttr>,
+        namei: Arg<LoadSuperAttr>,
     } = 96,
-    MakeCell(Arg<NameIdx>) = 97,
+    MakeCell {
+        i: Arg<NameIdx>,
+    } = 97,
     MapAdd {
         i: Arg<u32>,
     } = 98,
-    MatchClass(Arg<u32>) = 99,
+    MatchClass {
+        count: Arg<u32>,
+    } = 99,
     PopJumpIfFalse {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 100,
     PopJumpIfNone {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 101,
     PopJumpIfNotNone {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 102,
     PopJumpIfTrue {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 103,
     RaiseVarargs {
-        kind: Arg<RaiseKind>,
+        argc: Arg<RaiseKind>,
     } = 104,
     Reraise {
         depth: Arg<u32>,
     } = 105,
     Send {
-        target: Arg<Label>,
+        delta: Arg<Label>,
     } = 106,
     SetAdd {
         i: Arg<u32>,
     } = 107,
     SetFunctionAttribute {
-        attr: Arg<MakeFunctionFlags>,
+        flag: Arg<MakeFunctionFlags>,
     } = 108,
     SetUpdate {
         i: Arg<u32>,
     } = 109,
     StoreAttr {
-        idx: Arg<NameIdx>,
+        namei: Arg<NameIdx>,
     } = 110,
-    StoreDeref(Arg<NameIdx>) = 111,
-    StoreFast(Arg<NameIdx>) = 112,
+    StoreDeref {
+        i: Arg<NameIdx>,
+    } = 111,
+    StoreFast {
+        var_num: Arg<NameIdx>,
+    } = 112,
     StoreFastLoadFast {
         var_nums: Arg<StoreFastLoadFast>,
     } = 113,
     StoreFastStoreFast {
-        arg: Arg<u32>,
+        var_nums: Arg<u32>,
     } = 114,
-    StoreGlobal(Arg<NameIdx>) = 115,
-    StoreName(Arg<NameIdx>) = 116,
+    StoreGlobal {
+        namei: Arg<NameIdx>,
+    } = 115,
+    StoreName {
+        namei: Arg<NameIdx>,
+    } = 116,
     Swap {
-        index: Arg<u32>,
+        i: Arg<u32>,
     } = 117,
     UnpackEx {
-        args: Arg<UnpackExArgs>,
+        counts: Arg<UnpackExArgs>,
     } = 118,
     UnpackSequence {
-        size: Arg<u32>,
+        count: Arg<u32>,
     } = 119,
     YieldValue {
         arg: Arg<u32>,
     } = 120,
     // CPython 3.14 RESUME (128)
     Resume {
-        arg: Arg<u32>,
+        context: Arg<u32>,
     } = 128,
     // CPython 3.14 specialized opcodes (129-211)
     BinaryOpAddFloat = 129,                     // Placeholder
@@ -349,28 +391,28 @@ pub enum Instruction {
     UnpackSequenceTuple = 210,                  // Placeholder
     UnpackSequenceTwoTuple = 211,               // Placeholder
     // CPython 3.14 instrumented opcodes (234-254)
-    InstrumentedEndFor = 234,      // Placeholder
-    InstrumentedPopIter = 235,     // Placeholder
-    InstrumentedEndSend = 236,     // Placeholder
-    InstrumentedForIter = 237,     // Placeholder
-    InstrumentedInstruction = 238, // Placeholder
-    InstrumentedJumpForward = 239, // Placeholder
+    InstrumentedEndFor = 234,
+    InstrumentedPopIter = 235,
+    InstrumentedEndSend = 236,
+    InstrumentedForIter = 237,
+    InstrumentedInstruction = 238,
+    InstrumentedJumpForward = 239,
     InstrumentedNotTaken = 240,
-    InstrumentedPopJumpIfTrue = 241,    // Placeholder
-    InstrumentedPopJumpIfFalse = 242,   // Placeholder
-    InstrumentedPopJumpIfNone = 243,    // Placeholder
-    InstrumentedPopJumpIfNotNone = 244, // Placeholder
-    InstrumentedResume = 245,           // Placeholder
-    InstrumentedReturnValue = 246,      // Placeholder
-    InstrumentedYieldValue = 247,       // Placeholder
-    InstrumentedEndAsyncFor = 248,      // Placeholder
-    InstrumentedLoadSuperAttr = 249,    // Placeholder
-    InstrumentedCall = 250,             // Placeholder
-    InstrumentedCallKw = 251,           // Placeholder
-    InstrumentedCallFunctionEx = 252,   // Placeholder
-    InstrumentedJumpBackward = 253,     // Placeholder
-    InstrumentedLine = 254,             // Placeholder
-    EnterExecutor = 255,                // Placeholder
+    InstrumentedPopJumpIfTrue = 241,
+    InstrumentedPopJumpIfFalse = 242,
+    InstrumentedPopJumpIfNone = 243,
+    InstrumentedPopJumpIfNotNone = 244,
+    InstrumentedResume = 245,
+    InstrumentedReturnValue = 246,
+    InstrumentedYieldValue = 247,
+    InstrumentedEndAsyncFor = 248,
+    InstrumentedLoadSuperAttr = 249,
+    InstrumentedCall = 250,
+    InstrumentedCallKw = 251,
+    InstrumentedCallFunctionEx = 252,
+    InstrumentedJumpBackward = 253,
+    InstrumentedLine = 254,
+    EnterExecutor = 255, // Placeholder
 }
 
 const _: () = assert!(mem::size_of::<Instruction>() == 1);
@@ -393,7 +435,9 @@ impl TryFrom<u8> for Instruction {
         let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
 
         // Resume has a non-contiguous opcode (128)
-        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+        let resume_id = u8::from(Self::Resume {
+            context: Arg::marker(),
+        });
         let enter_executor_id = u8::from(Self::EnterExecutor);
 
         let specialized_start = u8::from(Self::BinaryOpAddFloat);
@@ -471,39 +515,43 @@ impl Instruction {
     /// only the opcode byte matters since `replace_op` preserves the arg byte.
     pub fn to_base(self) -> Option<Self> {
         Some(match self {
-            Self::InstrumentedResume => Self::Resume { arg: Arg::marker() },
+            Self::InstrumentedResume => Self::Resume {
+                context: Arg::marker(),
+            },
             Self::InstrumentedReturnValue => Self::ReturnValue,
             Self::InstrumentedYieldValue => Self::YieldValue { arg: Arg::marker() },
             Self::InstrumentedCall => Self::Call {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             Self::InstrumentedCallKw => Self::CallKw {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             Self::InstrumentedCallFunctionEx => Self::CallFunctionEx,
-            Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr { arg: Arg::marker() },
+            Self::InstrumentedLoadSuperAttr => Self::LoadSuperAttr {
+                namei: Arg::marker(),
+            },
             Self::InstrumentedJumpForward => Self::JumpForward {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedJumpBackward => Self::JumpBackward {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedForIter => Self::ForIter {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedEndFor => Self::EndFor,
             Self::InstrumentedEndSend => Self::EndSend,
             Self::InstrumentedPopJumpIfTrue => Self::PopJumpIfTrue {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedPopJumpIfFalse => Self::PopJumpIfFalse {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedPopJumpIfNone => Self::PopJumpIfNone {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedPopJumpIfNotNone => Self::PopJumpIfNotNone {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             Self::InstrumentedNotTaken => Self::NotTaken,
             Self::InstrumentedPopIter => Self::PopIter,
@@ -529,7 +577,9 @@ impl Instruction {
             | Self::LoadAttrNondescriptorWithValues
             | Self::LoadAttrProperty
             | Self::LoadAttrSlot
-            | Self::LoadAttrWithHint => Self::LoadAttr { idx: Arg::marker() },
+            | Self::LoadAttrWithHint => Self::LoadAttr {
+                namei: Arg::marker(),
+            },
             // BINARY_OP specializations
             Self::BinaryOpAddFloat
             | Self::BinaryOpAddInt
@@ -567,11 +617,11 @@ impl Instruction {
             | Self::CallStr1
             | Self::CallTuple1
             | Self::CallType1 => Self::Call {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             // CALL_KW specializations
             Self::CallKwBoundMethod | Self::CallKwNonPy | Self::CallKwPy => Self::CallKw {
-                nargs: Arg::marker(),
+                argc: Arg::marker(),
             },
             // TO_BOOL specializations
             Self::ToBoolAlwaysTrue
@@ -581,48 +631,56 @@ impl Instruction {
             | Self::ToBoolNone
             | Self::ToBoolStr => Self::ToBool,
             // COMPARE_OP specializations
-            Self::CompareOpFloat | Self::CompareOpInt | Self::CompareOpStr => {
-                Self::CompareOp { op: Arg::marker() }
-            }
+            Self::CompareOpFloat | Self::CompareOpInt | Self::CompareOpStr => Self::CompareOp {
+                opname: Arg::marker(),
+            },
             // CONTAINS_OP specializations
-            Self::ContainsOpDict | Self::ContainsOpSet => Self::ContainsOp(Arg::marker()),
+            Self::ContainsOpDict | Self::ContainsOpSet => Self::ContainsOp {
+                invert: Arg::marker(),
+            },
             // FOR_ITER specializations
             Self::ForIterGen | Self::ForIterList | Self::ForIterRange | Self::ForIterTuple => {
                 Self::ForIter {
-                    target: Arg::marker(),
+                    delta: Arg::marker(),
                 }
             }
             // LOAD_GLOBAL specializations
-            Self::LoadGlobalBuiltin | Self::LoadGlobalModule => Self::LoadGlobal(Arg::marker()),
+            Self::LoadGlobalBuiltin | Self::LoadGlobalModule => Self::LoadGlobal {
+                namei: Arg::marker(),
+            },
             // STORE_ATTR specializations
             Self::StoreAttrInstanceValue | Self::StoreAttrSlot | Self::StoreAttrWithHint => {
-                Self::StoreAttr { idx: Arg::marker() }
+                Self::StoreAttr {
+                    namei: Arg::marker(),
+                }
             }
             // LOAD_SUPER_ATTR specializations
-            Self::LoadSuperAttrAttr | Self::LoadSuperAttrMethod => {
-                Self::LoadSuperAttr { arg: Arg::marker() }
-            }
+            Self::LoadSuperAttrAttr | Self::LoadSuperAttrMethod => Self::LoadSuperAttr {
+                namei: Arg::marker(),
+            },
             // STORE_SUBSCR specializations
             Self::StoreSubscrDict | Self::StoreSubscrListInt => Self::StoreSubscr,
             // UNPACK_SEQUENCE specializations
             Self::UnpackSequenceList | Self::UnpackSequenceTuple | Self::UnpackSequenceTwoTuple => {
                 Self::UnpackSequence {
-                    size: Arg::marker(),
+                    count: Arg::marker(),
                 }
             }
             // SEND specializations
             Self::SendGen => Self::Send {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             // LOAD_CONST specializations
-            Self::LoadConstImmortal | Self::LoadConstMortal => {
-                Self::LoadConst { idx: Arg::marker() }
-            }
+            Self::LoadConstImmortal | Self::LoadConstMortal => Self::LoadConst {
+                consti: Arg::marker(),
+            },
             // RESUME specializations
-            Self::ResumeCheck => Self::Resume { arg: Arg::marker() },
+            Self::ResumeCheck => Self::Resume {
+                context: Arg::marker(),
+            },
             // JUMP_BACKWARD specializations
             Self::JumpBackwardJit | Self::JumpBackwardNoJit => Self::JumpBackward {
-                target: Arg::marker(),
+                delta: Arg::marker(),
             },
             // Instrumented opcodes map back to their base
             _ => match self.to_base() {
@@ -671,7 +729,7 @@ impl Instruction {
             | Self::BinaryOpSubtractInt => 5,
 
             // LOAD_GLOBAL / STORE_ATTR: 4 cache entries
-            Self::LoadGlobal(_)
+            Self::LoadGlobal { .. }
             | Self::LoadGlobalBuiltin
             | Self::LoadGlobalModule
             | Self::StoreAttr { .. }
@@ -718,7 +776,7 @@ impl Instruction {
             | Self::CompareOpFloat
             | Self::CompareOpInt
             | Self::CompareOpStr
-            | Self::ContainsOp(_)
+            | Self::ContainsOp { .. }
             | Self::ContainsOpDict
             | Self::ContainsOpSet
             | Self::ForIter { .. }
@@ -759,15 +817,15 @@ impl InstructionMetadata for Instruction {
     #[inline]
     fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::JumpBackward { target: l }
-            | Self::JumpBackwardNoInterrupt { target: l }
-            | Self::JumpForward { target: l }
-            | Self::PopJumpIfTrue { target: l }
-            | Self::PopJumpIfFalse { target: l }
-            | Self::PopJumpIfNone { target: l }
-            | Self::PopJumpIfNotNone { target: l }
-            | Self::ForIter { target: l }
-            | Self::Send { target: l } => Some(*l),
+            Self::JumpBackward { delta: l }
+            | Self::JumpBackwardNoInterrupt { delta: l }
+            | Self::JumpForward { delta: l }
+            | Self::PopJumpIfTrue { delta: l }
+            | Self::PopJumpIfFalse { delta: l }
+            | Self::PopJumpIfNone { delta: l }
+            | Self::PopJumpIfNotNone { delta: l }
+            | Self::ForIter { delta: l }
+            | Self::Send { delta: l } => Some(*l),
             _ => None,
         }
     }
@@ -857,17 +915,17 @@ impl InstructionMetadata for Instruction {
             Self::CompareOpFloat => (1, 2),
             Self::CompareOpInt => (1, 2),
             Self::CompareOpStr => (1, 2),
-            Self::ContainsOp(_) => (1, 2),
+            Self::ContainsOp { .. } => (1, 2),
             Self::ContainsOpDict => (1, 2),
             Self::ContainsOpSet => (1, 2),
             Self::ConvertValue { .. } => (1, 1),
             Self::Copy { .. } => (2 + (oparg - 1), 1 + (oparg - 1)),
             Self::CopyFreeVars { .. } => (0, 0),
             Self::DeleteAttr { .. } => (0, 1),
-            Self::DeleteDeref(_) => (0, 0),
-            Self::DeleteFast(_) => (0, 0),
-            Self::DeleteGlobal(_) => (0, 0),
-            Self::DeleteName(_) => (0, 0),
+            Self::DeleteDeref { .. } => (0, 0),
+            Self::DeleteFast { .. } => (0, 0),
+            Self::DeleteGlobal { .. } => (0, 0),
+            Self::DeleteName { .. } => (0, 0),
             Self::DeleteSubscr => (0, 2),
             Self::DictMerge { .. } => (4 + (oparg - 1), 5 + (oparg - 1)),
             Self::DictUpdate { .. } => (1 + (oparg - 1), 2 + (oparg - 1)),
@@ -914,7 +972,7 @@ impl InstructionMetadata for Instruction {
             Self::InstrumentedReturnValue => (1, 1),
             Self::InstrumentedYieldValue => (1, 1),
             Self::InterpreterExit => (0, 1),
-            Self::IsOp(_) => (1, 2),
+            Self::IsOp { .. } => (1, 2),
             Self::JumpBackward { .. } => (0, 0),
             Self::JumpBackwardJit => (0, 0),
             Self::JumpBackwardNoInterrupt { .. } => (0, 0),
@@ -941,26 +999,26 @@ impl InstructionMetadata for Instruction {
             Self::LoadConst { .. } => (1, 0),
             Self::LoadConstImmortal => (1, 0),
             Self::LoadConstMortal => (1, 0),
-            Self::LoadDeref(_) => (1, 0),
-            Self::LoadFast(_) => (1, 0),
-            Self::LoadFastAndClear(_) => (1, 0),
-            Self::LoadFastBorrow(_) => (1, 0),
+            Self::LoadDeref { .. } => (1, 0),
+            Self::LoadFast { .. } => (1, 0),
+            Self::LoadFastAndClear { .. } => (1, 0),
+            Self::LoadFastBorrow { .. } => (1, 0),
             Self::LoadFastBorrowLoadFastBorrow { .. } => (2, 0),
-            Self::LoadFastCheck(_) => (1, 0),
+            Self::LoadFastCheck { .. } => (1, 0),
             Self::LoadFastLoadFast { .. } => (2, 0),
-            Self::LoadFromDictOrDeref(_) => (1, 1),
-            Self::LoadFromDictOrGlobals(_) => (1, 1),
-            Self::LoadGlobal(_) => (1 + (oparg & 1), 0),
+            Self::LoadFromDictOrDeref { .. } => (1, 1),
+            Self::LoadFromDictOrGlobals { .. } => (1, 1),
+            Self::LoadGlobal { .. } => (1 + (oparg & 1), 0),
             Self::LoadGlobalBuiltin => (1 + (oparg & 1), 0),
             Self::LoadGlobalModule => (1 + (oparg & 1), 0),
             Self::LoadLocals => (1, 0),
-            Self::LoadName(_) => (1, 0),
+            Self::LoadName { .. } => (1, 0),
             Self::LoadSmallInt { .. } => (1, 0),
             Self::LoadSpecial { .. } => (1, 1),
             Self::LoadSuperAttr { .. } => (1 + (oparg & 1), 3),
             Self::LoadSuperAttrAttr => (1, 3),
             Self::LoadSuperAttrMethod => (2, 3),
-            Self::MakeCell(_) => (0, 0),
+            Self::MakeCell { .. } => (0, 0),
             Self::MakeFunction { .. } => (1, 1),
             Self::MapAdd { .. } => (1 + (oparg - 1), 3 + (oparg - 1)),
             Self::MatchClass { .. } => (1, 3),
@@ -995,12 +1053,12 @@ impl InstructionMetadata for Instruction {
             Self::StoreAttrInstanceValue => (0, 2),
             Self::StoreAttrSlot => (0, 2),
             Self::StoreAttrWithHint => (0, 2),
-            Self::StoreDeref(_) => (0, 1),
-            Self::StoreFast(_) => (0, 1),
+            Self::StoreDeref { .. } => (0, 1),
+            Self::StoreFast { .. } => (0, 1),
             Self::StoreFastLoadFast { .. } => (1, 1),
             Self::StoreFastStoreFast { .. } => (0, 2),
-            Self::StoreGlobal(_) => (0, 1),
-            Self::StoreName(_) => (0, 1),
+            Self::StoreGlobal { .. } => (0, 1),
+            Self::StoreName { .. } => (0, 1),
             Self::StoreSlice => (0, 4),
             Self::StoreSubscr => (0, 3),
             Self::StoreSubscrDict => (0, 3),
@@ -1087,58 +1145,58 @@ impl InstructionMetadata for Instruction {
             Self::BinarySlice => w!(BINARY_SLICE),
             Self::BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
             Self::BinaryOpInplaceAddUnicode => w!(BINARY_OP_INPLACE_ADD_UNICODE),
-            Self::BuildList { size } => w!(BUILD_LIST, size),
-            Self::BuildMap { size } => w!(BUILD_MAP, size),
-            Self::BuildSet { size } => w!(BUILD_SET, size),
+            Self::BuildList { count } => w!(BUILD_LIST, count),
+            Self::BuildMap { count } => w!(BUILD_MAP, count),
+            Self::BuildSet { count } => w!(BUILD_SET, count),
             Self::BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
-            Self::BuildString { size } => w!(BUILD_STRING, size),
-            Self::BuildTuple { size } => w!(BUILD_TUPLE, size),
-            Self::Call { nargs } => w!(CALL, nargs),
+            Self::BuildString { count } => w!(BUILD_STRING, count),
+            Self::BuildTuple { count } => w!(BUILD_TUPLE, count),
+            Self::Call { argc } => w!(CALL, argc),
             Self::CallFunctionEx => w!(CALL_FUNCTION_EX),
-            Self::CallKw { nargs } => w!(CALL_KW, nargs),
+            Self::CallKw { argc } => w!(CALL_KW, argc),
             Self::CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
             Self::CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
             Self::Cache => w!(CACHE),
             Self::CheckEgMatch => w!(CHECK_EG_MATCH),
             Self::CheckExcMatch => w!(CHECK_EXC_MATCH),
             Self::CleanupThrow => w!(CLEANUP_THROW),
-            Self::CompareOp { op } => w!(COMPARE_OP, ?op),
-            Self::ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
+            Self::CompareOp { opname } => w!(COMPARE_OP, ?opname),
+            Self::ContainsOp { invert } => w!(CONTAINS_OP, ?invert),
             Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
-            Self::Copy { index } => w!(COPY, index),
-            Self::CopyFreeVars { count } => w!(COPY_FREE_VARS, count),
-            Self::DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
-            Self::DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
-            Self::DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
-            Self::DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
-            Self::DeleteName(idx) => w!(DELETE_NAME, name = idx),
+            Self::Copy { i } => w!(COPY, i),
+            Self::CopyFreeVars { n } => w!(COPY_FREE_VARS, n),
+            Self::DeleteAttr { namei } => w!(DELETE_ATTR, name = namei),
+            Self::DeleteDeref { i } => w!(DELETE_DEREF, cell_name = i),
+            Self::DeleteFast { var_num } => w!(DELETE_FAST, varname = var_num),
+            Self::DeleteGlobal { namei } => w!(DELETE_GLOBAL, name = namei),
+            Self::DeleteName { namei } => w!(DELETE_NAME, name = namei),
             Self::DeleteSubscr => w!(DELETE_SUBSCR),
-            Self::DictMerge { index } => w!(DICT_MERGE, index),
-            Self::DictUpdate { index } => w!(DICT_UPDATE, index),
+            Self::DictMerge { i } => w!(DICT_MERGE, i),
+            Self::DictUpdate { i } => w!(DICT_UPDATE, i),
             Self::EndAsyncFor => w!(END_ASYNC_FOR),
             Self::EndSend => w!(END_SEND),
             Self::ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
             Self::ExitInitCheck => w!(EXIT_INIT_CHECK),
-            Self::ForIter { target } => w!(FOR_ITER, target),
+            Self::ForIter { delta } => w!(FOR_ITER, delta),
             Self::FormatSimple => w!(FORMAT_SIMPLE),
             Self::FormatWithSpec => w!(FORMAT_WITH_SPEC),
             Self::GetAIter => w!(GET_AITER),
             Self::GetANext => w!(GET_ANEXT),
-            Self::GetAwaitable { arg } => w!(GET_AWAITABLE, arg),
+            Self::GetAwaitable { r#where } => w!(GET_AWAITABLE, r#where),
             Self::Reserved => w!(RESERVED),
             Self::GetIter => w!(GET_ITER),
             Self::GetLen => w!(GET_LEN),
-            Self::ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
-            Self::ImportName { idx } => w!(IMPORT_NAME, name = idx),
+            Self::ImportFrom { namei } => w!(IMPORT_FROM, name = namei),
+            Self::ImportName { namei } => w!(IMPORT_NAME, name = namei),
             Self::InterpreterExit => w!(INTERPRETER_EXIT),
-            Self::IsOp(inv) => w!(IS_OP, ?inv),
-            Self::JumpBackward { target } => w!(JUMP_BACKWARD, target),
-            Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
-            Self::JumpForward { target } => w!(JUMP_FORWARD, target),
+            Self::IsOp { invert } => w!(IS_OP, ?invert),
+            Self::JumpBackward { delta } => w!(JUMP_BACKWARD, delta),
+            Self::JumpBackwardNoInterrupt { delta } => w!(JUMP_BACKWARD_NO_INTERRUPT, delta),
+            Self::JumpForward { delta } => w!(JUMP_FORWARD, delta),
             Self::ListAppend { i } => w!(LIST_APPEND, i),
             Self::ListExtend { i } => w!(LIST_EXTEND, i),
-            Self::LoadAttr { idx } => {
-                let oparg = idx.get(arg);
+            Self::LoadAttr { namei } => {
+                let oparg = namei.get(arg);
                 let oparg_u32 = u32::from(oparg);
                 let attr_name = name(oparg.name_idx());
                 if oparg.is_method() {
@@ -1153,24 +1211,24 @@ impl InstructionMetadata for Instruction {
             }
             Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
             Self::LoadCommonConstant { idx } => w!(LOAD_COMMON_CONSTANT, ?idx),
-            Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
-            Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
-            Self::LoadSmallInt { idx } => w!(LOAD_SMALL_INT, idx),
-            Self::LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
-            Self::LoadFast(idx) => w!(LOAD_FAST, varname = idx),
-            Self::LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
-            Self::LoadFastBorrow(idx) => w!(LOAD_FAST_BORROW, varname = idx),
-            Self::LoadFastCheck(idx) => w!(LOAD_FAST_CHECK, varname = idx),
-            Self::LoadFastLoadFast { arg: packed } => {
-                let oparg = packed.get(arg);
+            Self::LoadFromDictOrDeref { i } => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
+            Self::LoadConst { consti } => fmt_const("LOAD_CONST", arg, f, consti),
+            Self::LoadSmallInt { i } => w!(LOAD_SMALL_INT, i),
+            Self::LoadDeref { i } => w!(LOAD_DEREF, cell_name = i),
+            Self::LoadFast { var_num } => w!(LOAD_FAST, varname = var_num),
+            Self::LoadFastAndClear { var_num } => w!(LOAD_FAST_AND_CLEAR, varname = var_num),
+            Self::LoadFastBorrow { var_num } => w!(LOAD_FAST_BORROW, varname = var_num),
+            Self::LoadFastCheck { var_num } => w!(LOAD_FAST_CHECK, varname = var_num),
+            Self::LoadFastLoadFast { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 15;
                 let name1 = varname(idx1);
                 let name2 = varname(idx2);
                 write!(f, "{:pad$}({}, {})", "LOAD_FAST_LOAD_FAST", name1, name2)
             }
-            Self::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
+            Self::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 15;
                 let name1 = varname(idx1);
@@ -1181,9 +1239,9 @@ impl InstructionMetadata for Instruction {
                     "LOAD_FAST_BORROW_LOAD_FAST_BORROW", name1, name2
                 )
             }
-            Self::LoadFromDictOrGlobals(idx) => w!(LOAD_FROM_DICT_OR_GLOBALS, name = idx),
-            Self::LoadGlobal(idx) => {
-                let oparg = idx.get(arg);
+            Self::LoadFromDictOrGlobals { i } => w!(LOAD_FROM_DICT_OR_GLOBALS, name = i),
+            Self::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
                 let name_idx = oparg >> 1;
                 if (oparg & 1) != 0 {
                     write!(
@@ -1240,10 +1298,10 @@ impl InstructionMetadata for Instruction {
                 }
             }
             Self::LoadLocals => w!(LOAD_LOCALS),
-            Self::LoadName(idx) => w!(LOAD_NAME, name = idx),
+            Self::LoadName { namei } => w!(LOAD_NAME, name = namei),
             Self::LoadSpecial { method } => w!(LOAD_SPECIAL, method),
-            Self::LoadSuperAttr { arg: idx } => {
-                let oparg = idx.get(arg);
+            Self::LoadSuperAttr { namei } => {
+                let oparg = namei.get(arg);
                 write!(
                     f,
                     "{:pad$}({}, {}, method={}, class={})",
@@ -1254,38 +1312,38 @@ impl InstructionMetadata for Instruction {
                     oparg.has_class()
                 )
             }
-            Self::MakeCell(idx) => w!(MAKE_CELL, cell_name = idx),
+            Self::MakeCell { i } => w!(MAKE_CELL, cell_name = i),
             Self::MakeFunction => w!(MAKE_FUNCTION),
             Self::MapAdd { i } => w!(MAP_ADD, i),
-            Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
+            Self::MatchClass { count } => w!(MATCH_CLASS, count),
             Self::MatchKeys => w!(MATCH_KEYS),
             Self::MatchMapping => w!(MATCH_MAPPING),
             Self::MatchSequence => w!(MATCH_SEQUENCE),
             Self::Nop => w!(NOP),
             Self::NotTaken => w!(NOT_TAKEN),
             Self::PopExcept => w!(POP_EXCEPT),
-            Self::PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
-            Self::PopJumpIfNone { target } => w!(POP_JUMP_IF_NONE, target),
-            Self::PopJumpIfNotNone { target } => w!(POP_JUMP_IF_NOT_NONE, target),
-            Self::PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
+            Self::PopJumpIfFalse { delta } => w!(POP_JUMP_IF_FALSE, delta),
+            Self::PopJumpIfNone { delta } => w!(POP_JUMP_IF_NONE, delta),
+            Self::PopJumpIfNotNone { delta } => w!(POP_JUMP_IF_NOT_NONE, delta),
+            Self::PopJumpIfTrue { delta } => w!(POP_JUMP_IF_TRUE, delta),
             Self::PopTop => w!(POP_TOP),
             Self::EndFor => w!(END_FOR),
             Self::PopIter => w!(POP_ITER),
             Self::PushExcInfo => w!(PUSH_EXC_INFO),
             Self::PushNull => w!(PUSH_NULL),
-            Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
+            Self::RaiseVarargs { argc } => w!(RAISE_VARARGS, ?argc),
             Self::Reraise { depth } => w!(RERAISE, depth),
-            Self::Resume { arg } => w!(RESUME, arg),
+            Self::Resume { context } => w!(RESUME, context),
             Self::ReturnValue => w!(RETURN_VALUE),
             Self::ReturnGenerator => w!(RETURN_GENERATOR),
-            Self::Send { target } => w!(SEND, target),
+            Self::Send { delta } => w!(SEND, delta),
             Self::SetAdd { i } => w!(SET_ADD, i),
-            Self::SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
+            Self::SetFunctionAttribute { flag } => w!(SET_FUNCTION_ATTRIBUTE, ?flag),
             Self::SetupAnnotations => w!(SETUP_ANNOTATIONS),
             Self::SetUpdate { i } => w!(SET_UPDATE, i),
-            Self::StoreAttr { idx } => w!(STORE_ATTR, name = idx),
-            Self::StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
-            Self::StoreFast(idx) => w!(STORE_FAST, varname = idx),
+            Self::StoreAttr { namei } => w!(STORE_ATTR, name = namei),
+            Self::StoreDeref { i } => w!(STORE_DEREF, cell_name = i),
+            Self::StoreFast { var_num } => w!(STORE_FAST, varname = var_num),
             Self::StoreFastLoadFast { var_nums } => {
                 let oparg = var_nums.get(arg);
                 let store_idx = oparg.store_idx();
@@ -1293,8 +1351,8 @@ impl InstructionMetadata for Instruction {
                 write!(f, "STORE_FAST_LOAD_FAST")?;
                 write!(f, " ({}, {})", store_idx, load_idx)
             }
-            Self::StoreFastStoreFast { arg: packed } => {
-                let oparg = packed.get(arg);
+            Self::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 15;
                 write!(
@@ -1305,14 +1363,14 @@ impl InstructionMetadata for Instruction {
                     varname(idx2)
                 )
             }
-            Self::StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
-            Self::StoreName(idx) => w!(STORE_NAME, name = idx),
+            Self::StoreGlobal { namei } => w!(STORE_GLOBAL, name = namei),
+            Self::StoreName { namei } => w!(STORE_NAME, name = namei),
             Self::StoreSlice => w!(STORE_SLICE),
             Self::StoreSubscr => w!(STORE_SUBSCR),
-            Self::Swap { index } => w!(SWAP, index),
+            Self::Swap { i } => w!(SWAP, i),
             Self::ToBool => w!(TO_BOOL),
-            Self::UnpackEx { args } => w!(UNPACK_EX, args),
-            Self::UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
+            Self::UnpackEx { counts } => w!(UNPACK_EX, counts),
+            Self::UnpackSequence { count } => w!(UNPACK_SEQUENCE, count),
             Self::WithExceptStart => w!(WITH_EXCEPT_START),
             Self::UnaryInvert => w!(UNARY_INVERT),
             Self::UnaryNegative => w!(UNARY_NEGATIVE),
@@ -1320,7 +1378,7 @@ impl InstructionMetadata for Instruction {
             Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
             Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
             Self::BuildTemplate => w!(BUILD_TEMPLATE),
-            Self::BuildInterpolation { oparg } => w!(BUILD_INTERPOLATION, oparg),
+            Self::BuildInterpolation { format } => w!(BUILD_INTERPOLATION, format),
             _ => w!(RUSTPYTHON_PLACEHOLDER),
         }
     }
@@ -1334,16 +1392,16 @@ impl InstructionMetadata for Instruction {
 pub enum PseudoInstruction {
     // CPython 3.14.2 pseudo instructions (256-266)
     AnnotationsPlaceholder = 256,
-    Jump { target: Arg<Label> } = 257,
-    JumpIfFalse { target: Arg<Label> } = 258,
-    JumpIfTrue { target: Arg<Label> } = 259,
-    JumpNoInterrupt { target: Arg<Label> } = 260,
-    LoadClosure(Arg<NameIdx>) = 261,
+    Jump { delta: Arg<Label> } = 257,
+    JumpIfFalse { delta: Arg<Label> } = 258,
+    JumpIfTrue { delta: Arg<Label> } = 259,
+    JumpNoInterrupt { delta: Arg<Label> } = 260,
+    LoadClosure { i: Arg<NameIdx> } = 261,
     PopBlock = 262,
-    SetupCleanup { target: Arg<Label> } = 263,
-    SetupFinally { target: Arg<Label> } = 264,
-    SetupWith { target: Arg<Label> } = 265,
-    StoreFastMaybeNull(Arg<NameIdx>) = 266,
+    SetupCleanup { delta: Arg<Label> } = 263,
+    SetupFinally { delta: Arg<Label> } = 264,
+    SetupWith { delta: Arg<Label> } = 265,
+    StoreFastMaybeNull { var_num: Arg<NameIdx> } = 266,
 }
 
 const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
@@ -1362,7 +1420,9 @@ impl TryFrom<u16> for PseudoInstruction {
     #[inline]
     fn try_from(value: u16) -> Result<Self, MarshalError> {
         let start = u16::from(Self::AnnotationsPlaceholder);
-        let end = u16::from(Self::StoreFastMaybeNull(Arg::marker()));
+        let end = u16::from(Self::StoreFastMaybeNull {
+            var_num: Arg::marker(),
+        });
 
         if (start..=end).contains(&value) {
             Ok(unsafe { mem::transmute::<u16, Self>(value) })
@@ -1386,13 +1446,13 @@ impl PseudoInstruction {
 impl InstructionMetadata for PseudoInstruction {
     fn label_arg(&self) -> Option<Arg<Label>> {
         match self {
-            Self::Jump { target: l }
-            | Self::JumpIfFalse { target: l }
-            | Self::JumpIfTrue { target: l }
-            | Self::JumpNoInterrupt { target: l }
-            | Self::SetupCleanup { target: l }
-            | Self::SetupFinally { target: l }
-            | Self::SetupWith { target: l } => Some(*l),
+            Self::Jump { delta: l }
+            | Self::JumpIfFalse { delta: l }
+            | Self::JumpIfTrue { delta: l }
+            | Self::JumpNoInterrupt { delta: l }
+            | Self::SetupCleanup { delta: l }
+            | Self::SetupFinally { delta: l }
+            | Self::SetupWith { delta: l } => Some(*l),
             _ => None,
         }
     }
@@ -1414,14 +1474,14 @@ impl InstructionMetadata for PseudoInstruction {
             Self::JumpIfFalse { .. } => (1, 1),
             Self::JumpIfTrue { .. } => (1, 1),
             Self::JumpNoInterrupt { .. } => (0, 0),
-            Self::LoadClosure(_) => (1, 0),
+            Self::LoadClosure { .. } => (1, 0),
             Self::PopBlock => (0, 0),
             // Normal path effect is 0 (these are NOPs on fall-through).
             // Handler entry effects are computed directly in max_stackdepth().
             Self::SetupCleanup { .. } => (0, 0),
             Self::SetupFinally { .. } => (0, 0),
             Self::SetupWith { .. } => (0, 0),
-            Self::StoreFastMaybeNull(_) => (0, 1),
+            Self::StoreFastMaybeNull { .. } => (0, 1),
         };
 
         debug_assert!((0..=i32::MAX).contains(&pushed));
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
index 2fa72c6e375..5bf4057b340 100644
--- a/crates/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -512,13 +512,13 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize);
+            Instruction::BuildTuple { count } => {
+                let elements = self.pop_multiple(count.get(arg) as usize);
                 self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::Call { nargs } => {
-                let nargs = nargs.get(arg);
+            Instruction::Call { argc } => {
+                let nargs = argc.get(arg);
 
                 let mut args = Vec::new();
                 for _ in 0..nargs {
@@ -562,8 +562,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::CompareOp { op, .. } => {
-                let op = op.get(arg);
+            Instruction::CompareOp { opname } => {
+                let op = opname.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)?;
@@ -627,20 +627,21 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.builder.ins().jump(target_block, &[]);
                 Ok(())
             }
-            Instruction::LoadConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+            Instruction::LoadConst { consti } => {
+                let val = self.prepare_const(
+                    bytecode.constants[consti.get(arg) as usize].borrow_constant(),
+                )?;
                 self.stack.push(val);
                 Ok(())
             }
-            Instruction::LoadSmallInt { idx } => {
-                let small_int = idx.get(arg) as i64;
+            Instruction::LoadSmallInt { i } => {
+                let small_int = i.get(arg) as i64;
                 let val = self.builder.ins().iconst(types::I64, small_int);
                 self.stack.push(JitValue::Int(val));
                 Ok(())
             }
-            Instruction::LoadFast(idx) | Instruction::LoadFastBorrow(idx) => {
-                let local = self.variables[idx.get(arg) as usize]
+            Instruction::LoadFast { var_num } | Instruction::LoadFastBorrow { var_num } => {
+                let local = self.variables[var_num.get(arg) as usize]
                     .as_ref()
                     .ok_or(JitCompileError::BadBytecode)?;
                 self.stack.push(JitValue::from_type_and_value(
@@ -649,9 +650,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 ));
                 Ok(())
             }
-            Instruction::LoadFastLoadFast { arg: packed }
-            | Instruction::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
+            Instruction::LoadFastLoadFast { var_nums }
+            | Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = oparg >> 4;
                 let idx2 = oparg & 0xF;
                 for idx in [idx1, idx2] {
@@ -665,8 +666,8 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 }
                 Ok(())
             }
-            Instruction::LoadGlobal(idx) => {
-                let oparg = idx.get(arg);
+            Instruction::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
                 let name = &bytecode.names[(oparg >> 1) as usize];
 
                 if name.as_ref() != bytecode.obj_name.as_ref() {
@@ -714,7 +715,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.pop();
                 Ok(())
             }
-            Instruction::Resume { arg: _resume_arg } => {
+            Instruction::Resume { .. } => {
                 // TODO: Implement the resume instruction
                 Ok(())
             }
@@ -722,11 +723,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
                 self.return_value(val)
             }
-            Instruction::StoreFast(idx) => {
+            Instruction::StoreFast { var_num } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(idx.get(arg), val)
+                self.store_variable(var_num.get(arg), val)
             }
-            Instruction::Swap { index } => {
+            Instruction::Swap { i: index } => {
                 let len = self.stack.len();
                 let i = len - 1;
                 let j = len - 1 - index.get(arg) as usize;
@@ -760,7 +761,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::NotSupported),
                 }
             }
-            Instruction::UnpackSequence { size } => {
+            Instruction::UnpackSequence { count } => {
                 let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
 
                 let elements = match val {
@@ -768,7 +769,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => return Err(JitCompileError::NotSupported),
                 };
 
-                if elements.len() != size.get(arg) as usize {
+                if elements.len() != count.get(arg) as usize {
                     return Err(JitCompileError::NotSupported);
                 }
 
diff --git a/crates/jit/tests/common.rs b/crates/jit/tests/common.rs
index 79b47c1bb16..095bb87d7be 100644
--- a/crates/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -76,17 +76,17 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
         let (instruction, arg) = op_arg_state.get(word);
 
         match instruction {
-            Instruction::LoadConst { idx } => {
-                stack.push((true, idx.get(arg) as usize));
+            Instruction::LoadConst { consti } => {
+                stack.push((true, consti.get(arg) as usize));
             }
-            Instruction::LoadName(idx) => {
-                stack.push((false, idx.get(arg) as usize));
+            Instruction::LoadName { namei } => {
+                stack.push((false, namei.get(arg) as usize));
             }
-            Instruction::LoadGlobal(idx) => {
-                stack.push((false, (idx.get(arg) >> 1) as usize));
+            Instruction::LoadGlobal { namei } => {
+                stack.push((false, (namei.get(arg) >> 1) as usize));
             }
-            Instruction::BuildMap { size, .. } => {
-                let count = size.get(arg) as usize;
+            Instruction::BuildMap { count } => {
+                let count = count.get(arg) as usize;
                 // Stack has key-value pairs in order: k1, v1, k2, v2, ...
                 // So we need count * 2 items from the stack
                 let start = stack.len().saturating_sub(count * 2);
@@ -139,7 +139,7 @@ fn extract_annotations_from_annotate_code(code: &CodeObject) -> HashMap<Wtf8Buf,
                 return annotations;
             }
             Instruction::Resume { .. }
-            | Instruction::LoadFast(_)
+            | Instruction::LoadFast { .. }
             | Instruction::CompareOp { .. }
             | Instruction::ExtendedArg
             | Instruction::Cache
@@ -192,15 +192,15 @@ impl StackMachine {
             Instruction::Resume { .. } | Instruction::Cache | Instruction::NotTaken => {
                 // No-op for JIT tests
             }
-            Instruction::LoadConst { idx } => {
-                let idx = idx.get(arg);
+            Instruction::LoadConst { consti } => {
+                let idx = consti.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
-            Instruction::LoadName(idx) => self
+            Instruction::LoadName { namei } => self
                 .stack
-                .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            Instruction::StoreName(idx) => {
-                let idx = idx.get(arg);
+                .push(StackValue::String(names[namei.get(arg) as usize].clone())),
+            Instruction::StoreName { namei } => {
+                let idx = namei.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
             }
@@ -209,9 +209,9 @@ impl StackMachine {
                 self.stack.pop().unwrap();
                 self.stack.pop().unwrap();
             }
-            Instruction::BuildMap { size, .. } => {
+            Instruction::BuildMap { count } => {
                 let mut map = HashMap::new();
-                for _ in 0..size.get(arg) {
+                for _ in 0..count.get(arg) {
                     let value = self.stack.pop().unwrap();
                     let name = if let Some(StackValue::String(name)) = self.stack.pop() {
                         Wtf8Buf::from(name)
@@ -234,7 +234,7 @@ impl StackMachine {
                     annotations: HashMap::new(), // empty annotations, will be set later if needed
                 }));
             }
-            Instruction::SetFunctionAttribute { attr } => {
+            Instruction::SetFunctionAttribute { flag } => {
                 // Stack: [..., attr_value, func] -> [..., func]
                 let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
                     func
@@ -243,7 +243,7 @@ impl StackMachine {
                 };
                 let attr_value = self.stack.pop().expect("Expected attribute value on stack");
 
-                let flags = attr.get(arg);
+                let flags = flag.get(arg);
 
                 // Handle ANNOTATE flag (PEP 649 style - Python 3.14+)
                 // The attr_value is a function that returns annotations when called
diff --git a/crates/stdlib/src/_opcode.rs b/crates/stdlib/src/_opcode.rs
index f2b447e78b6..ba1e6120fc0 100644
--- a/crates/stdlib/src/_opcode.rs
+++ b/crates/stdlib/src/_opcode.rs
@@ -82,16 +82,16 @@ mod _opcode {
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
                     Instruction::DeleteAttr { .. }
-                        | Instruction::DeleteGlobal(_)
-                        | Instruction::DeleteName(_)
+                        | Instruction::DeleteGlobal { .. }
+                        | Instruction::DeleteName { .. }
                         | Instruction::ImportFrom { .. }
                         | Instruction::ImportName { .. }
                         | Instruction::LoadAttr { .. }
-                        | Instruction::LoadGlobal(_)
-                        | Instruction::LoadName(_)
+                        | Instruction::LoadGlobal { .. }
+                        | Instruction::LoadName { .. }
                         | Instruction::StoreAttr { .. }
-                        | Instruction::StoreGlobal(_)
-                        | Instruction::StoreName(_)
+                        | Instruction::StoreGlobal { .. }
+                        | Instruction::StoreName { .. }
                 ))
             )
         }
@@ -116,10 +116,10 @@ mod _opcode {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
-                    Instruction::DeleteDeref(_)
-                        | Instruction::LoadFromDictOrDeref(_)
-                        | Instruction::LoadDeref(_)
-                        | Instruction::StoreDeref(_)
+                    Instruction::DeleteDeref { .. }
+                        | Instruction::LoadFromDictOrDeref { .. }
+                        | Instruction::LoadDeref { .. }
+                        | Instruction::StoreDeref { .. }
                 ))
             )
         }
@@ -130,10 +130,10 @@ mod _opcode {
             matches!(
                 Self::try_from(opcode).map(|op| op.inner()),
                 Ok(AnyInstruction::Real(
-                    Instruction::DeleteFast(_)
-                        | Instruction::LoadFast(_)
-                        | Instruction::LoadFastAndClear(_)
-                        | Instruction::StoreFast(_)
+                    Instruction::DeleteFast { .. }
+                        | Instruction::LoadFast { .. }
+                        | Instruction::LoadFastAndClear { .. }
+                        | Instruction::StoreFast { .. }
                         | Instruction::StoreFastLoadFast { .. }
                 ))
             )
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
index b3a90690eac..602810b4cdb 100644
--- a/crates/vm/src/builtins/frame.rs
+++ b/crates/vm/src/builtins/frame.rs
@@ -295,7 +295,7 @@ pub(crate) mod stack_analysis {
                             stacks[next_i] = next_stack;
                         }
                     }
-                    Instruction::LoadGlobal(_) => {
+                    Instruction::LoadGlobal { .. } => {
                         next_stack = push_value(next_stack, Kind::Object as i64);
                         if oparg & 1 != 0 {
                             next_stack = push_value(next_stack, Kind::Null as i64);
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
index ad077132ef1..fc4cefc147c 100644
--- a/crates/vm/src/frame.rs
+++ b/crates/vm/src/frame.rs
@@ -884,8 +884,8 @@ impl ExecutingFrame<'_> {
                     // new traceback entries.
                     // EndAsyncFor and CleanupThrow also re-raise non-matching exceptions.
                     let is_reraise = match op {
-                        Instruction::RaiseVarargs { kind } => matches!(
-                            kind.get(arg),
+                        Instruction::RaiseVarargs { argc } => matches!(
+                            argc.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
                         Instruction::Reraise { .. }
@@ -898,9 +898,9 @@ impl ExecutingFrame<'_> {
                     // need contextualization even if the exception has prior traceback
                     let is_new_raise = matches!(
                         op,
-                        Instruction::RaiseVarargs { kind }
+                        Instruction::RaiseVarargs { argc }
                             if matches!(
-                                kind.get(arg),
+                                argc.get(arg),
                                 bytecode::RaiseKind::Raise | bytecode::RaiseKind::RaiseCause
                             )
                     );
@@ -1303,17 +1303,17 @@ impl ExecutingFrame<'_> {
                 self.push_value(result);
                 Ok(None)
             }
-            Instruction::BuildList { size } => {
-                let sz = size.get(arg) as usize;
+            Instruction::BuildList { count } => {
+                let sz = count.get(arg) as usize;
                 let elements = self.pop_multiple(sz).collect();
                 let list_obj = vm.ctx.new_list(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
             }
-            Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            Instruction::BuildSet { size } => {
+            Instruction::BuildMap { count } => self.execute_build_map(vm, count.get(arg)),
+            Instruction::BuildSet { count } => {
                 let set = PySet::default().into_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
+                for element in self.pop_multiple(count.get(arg) as usize) {
                     set.add(element, vm)?;
                 }
                 self.push_value(set.into());
@@ -1330,16 +1330,16 @@ impl ExecutingFrame<'_> {
                  Ok(None)
             }
             */
-            Instruction::BuildString { size } => {
+            Instruction::BuildString { count } => {
                 let s: Wtf8Buf = self
-                    .pop_multiple(size.get(arg) as usize)
+                    .pop_multiple(count.get(arg) as usize)
                     .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
                     .collect();
                 self.push_value(vm.ctx.new_str(s).into());
                 Ok(None)
             }
-            Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+            Instruction::BuildTuple { count } => {
+                let elements = self.pop_multiple(count.get(arg) as usize).collect();
                 let list_obj = vm.ctx.new_tuple(elements);
                 self.push_value(list_obj.into());
                 Ok(None)
@@ -1360,10 +1360,10 @@ impl ExecutingFrame<'_> {
                 self.push_value(template.into_pyobject(vm));
                 Ok(None)
             }
-            Instruction::BuildInterpolation { oparg } => {
+            Instruction::BuildInterpolation { format } => {
                 // oparg encoding: (conversion << 2) | has_format_spec
                 // Stack: [value, expression_str, (format_spec)?] -> [interpolation]
-                let oparg_val = oparg.get(arg);
+                let oparg_val = format.get(arg);
                 let has_format_spec = (oparg_val & 1) != 0;
                 let conversion_code = oparg_val >> 2;
 
@@ -1394,9 +1394,9 @@ impl ExecutingFrame<'_> {
                 self.push_value(interpolation.into_pyobject(vm));
                 Ok(None)
             }
-            Instruction::Call { nargs } => {
+            Instruction::Call { argc } => {
                 // Stack: [callable, self_or_null, arg1, ..., argN]
-                let nargs_val = nargs.get(arg);
+                let nargs_val = argc.get(arg);
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_adaptive_counter(cache_base);
@@ -1412,8 +1412,8 @@ impl ExecutingFrame<'_> {
                 let args = self.collect_positional_args(nargs_val);
                 self.execute_call(args, vm)
             }
-            Instruction::CallKw { nargs } => {
-                let nargs = nargs.get(arg);
+            Instruction::CallKw { argc } => {
+                let nargs = argc.get(arg);
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_cache_u16(cache_base);
@@ -1466,8 +1466,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(matched);
                 Ok(None)
             }
-            Instruction::CompareOp { op } => {
-                let op_val = op.get(arg);
+            Instruction::CompareOp { opname } => {
+                let op_val = opname.get(arg);
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_cache_u16(cache_base);
@@ -1482,7 +1482,7 @@ impl ExecutingFrame<'_> {
                 }
                 self.execute_compare(vm, op_val)
             }
-            Instruction::ContainsOp(invert) => {
+            Instruction::ContainsOp { invert } => {
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_cache_u16(cache_base);
@@ -1506,14 +1506,12 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(value).into());
                 Ok(None)
             }
-            Instruction::ConvertValue { oparg: conversion } => {
-                self.convert_value(conversion.get(arg), vm)
-            }
-            Instruction::Copy { index } => {
+            Instruction::ConvertValue { oparg } => self.convert_value(oparg.get(arg), vm),
+            Instruction::Copy { i } => {
                 // 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 idx = i.get(arg) as usize;
                 let stack_len = self.state.stack.len();
                 debug_assert!(stack_len >= idx, "CopyItem: stack underflow");
                 let value = self.state.stack[stack_len - idx].clone();
@@ -1524,14 +1522,14 @@ impl ExecutingFrame<'_> {
                 // Free vars are already set up at frame creation time in RustPython
                 Ok(None)
             }
-            Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            Instruction::DeleteDeref(i) => {
+            Instruction::DeleteAttr { namei } => self.delete_attr(vm, namei.get(arg)),
+            Instruction::DeleteDeref { i } => {
                 self.state.cells_frees[i.get(arg) as usize].set(None);
                 Ok(None)
             }
-            Instruction::DeleteFast(idx) => {
+            Instruction::DeleteFast { var_num } => {
                 let fastlocals = unsafe { self.fastlocals.borrow_mut() };
-                let idx = idx.get(arg) as usize;
+                let idx = var_num.get(arg) as usize;
                 if fastlocals[idx].is_none() {
                     return Err(vm.new_exception_msg(
                         vm.ctx.exceptions.unbound_local_error.to_owned(),
@@ -1545,8 +1543,8 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx] = None;
                 Ok(None)
             }
-            Instruction::DeleteGlobal(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::DeleteGlobal { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 match self.globals.del_item(name, vm) {
                     Ok(()) => {}
                     Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
@@ -1556,8 +1554,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            Instruction::DeleteName(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::DeleteName { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 let res = self.locals.mapping(vm).ass_subscript(name, None, vm);
 
                 match res {
@@ -1570,12 +1568,12 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
-            Instruction::DictUpdate { index } => {
+            Instruction::DictUpdate { i } => {
                 // Stack before: [..., dict, ..., source]  (source at TOS)
                 // Stack after:  [..., dict, ...]  (source consumed)
                 // The dict to update is at position TOS-i (before popping source)
 
-                let idx = index.get(arg);
+                let idx = i.get(arg);
 
                 // Pop the source from TOS
                 let source = self.pop_value();
@@ -1606,9 +1604,9 @@ impl ExecutingFrame<'_> {
                 dict.merge_object(source, vm)?;
                 Ok(None)
             }
-            Instruction::DictMerge { index } => {
+            Instruction::DictMerge { i } => {
                 let source = self.pop_value();
-                let idx = index.get(arg);
+                let idx = i.get(arg);
 
                 // Get the dict to merge into (same logic as DICT_UPDATE)
                 let dict_ref = if idx <= 1 {
@@ -1760,7 +1758,7 @@ impl ExecutingFrame<'_> {
                 debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
                 Ok(None)
             }
-            Instruction::GetAwaitable { arg: oparg } => {
+            Instruction::GetAwaitable { r#where: oparg } => {
                 let iterable = self.pop_value();
 
                 let iter = match crate::coroutine::get_awaitable_iter(iterable.clone(), vm) {
@@ -1843,16 +1841,16 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_int(len).into());
                 Ok(None)
             }
-            Instruction::ImportFrom { idx } => {
-                let obj = self.import_from(vm, idx.get(arg))?;
+            Instruction::ImportFrom { namei } => {
+                let obj = self.import_from(vm, namei.get(arg))?;
                 self.push_value(obj);
                 Ok(None)
             }
-            Instruction::ImportName { idx } => {
-                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
+            Instruction::ImportName { namei } => {
+                self.import(vm, Some(self.code.names[namei.get(arg) as usize]))?;
                 Ok(None)
             }
-            Instruction::IsOp(invert) => {
+            Instruction::IsOp { invert } => {
                 let b = self.pop_value();
                 let a = self.pop_value();
                 let res = a.is(&b);
@@ -1912,8 +1910,8 @@ impl ExecutingFrame<'_> {
                 })?;
                 Ok(None)
             }
-            Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            Instruction::LoadSuperAttr { arg: idx } => {
+            Instruction::LoadAttr { namei } => self.load_attr(vm, namei.get(arg)),
+            Instruction::LoadSuperAttr { namei } => {
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_cache_u16(cache_base);
@@ -1924,9 +1922,9 @@ impl ExecutingFrame<'_> {
                             .write_cache_u16(cache_base, counter - 1);
                     }
                 } else {
-                    self.specialize_load_super_attr(vm, idx.get(arg), instr_idx, cache_base);
+                    self.specialize_load_super_attr(vm, namei.get(arg), instr_idx, cache_base);
                 }
-                self.load_super_attr(vm, idx.get(arg))
+                self.load_super_attr(vm, namei.get(arg))
             }
             Instruction::LoadBuildClass => {
                 let build_class = if let Some(builtins_dict) = self.builtins_dict {
@@ -1961,7 +1959,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(locals);
                 Ok(None)
             }
-            Instruction::LoadFromDictOrDeref(i) => {
+            Instruction::LoadFromDictOrDeref { i } => {
                 // Pop dict from stack (locals or classdict depending on context)
                 let class_dict = self.pop_value();
                 let i = i.get(arg) as usize;
@@ -1988,10 +1986,10 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            Instruction::LoadFromDictOrGlobals(idx) => {
+            Instruction::LoadFromDictOrGlobals { i } => {
                 // PEP 649: Pop dict from stack (classdict), check there first, then globals
                 let dict = self.pop_value();
-                let name = self.code.names[idx.get(arg) as usize];
+                let name = self.code.names[i.get(arg) as usize];
 
                 // Only treat KeyError as "not found", propagate other exceptions
                 let value = if let Some(dict_obj) = dict.downcast_ref::<PyDict>() {
@@ -2011,8 +2009,8 @@ impl ExecutingFrame<'_> {
                 });
                 Ok(None)
             }
-            Instruction::LoadConst { idx } => {
-                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
+            Instruction::LoadConst { consti } => {
+                self.push_value(self.code.constants[consti.get(arg) as usize].clone().into());
                 Ok(None)
             }
             Instruction::LoadCommonConstant { idx } => {
@@ -2031,13 +2029,13 @@ impl ExecutingFrame<'_> {
                 self.push_value(value);
                 Ok(None)
             }
-            Instruction::LoadSmallInt { idx } => {
+            Instruction::LoadSmallInt { i } => {
                 // Push small integer (-5..=256) directly without constant table lookup
-                let value = vm.ctx.new_int(idx.get(arg) as i32);
+                let value = vm.ctx.new_int(i.get(arg) as i32);
                 self.push_value(value.into());
                 Ok(None)
             }
-            Instruction::LoadDeref(i) => {
+            Instruction::LoadDeref { i } => {
                 let idx = i.get(arg) as usize;
                 let x = self.state.cells_frees[idx]
                     .get()
@@ -2045,7 +2043,7 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFast(idx) => {
+            Instruction::LoadFast { var_num } => {
                 #[cold]
                 fn reference_error(
                     varname: &'static PyStrInterned,
@@ -2056,27 +2054,27 @@ impl ExecutingFrame<'_> {
                         format!("local variable '{varname}' referenced before assignment").into(),
                     )
                 }
-                let idx = idx.get(arg) as usize;
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow() }[idx]
                     .clone()
                     .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastAndClear(idx) => {
+            Instruction::LoadFastAndClear { var_num } => {
                 // Load value and clear the slot (for inlined comprehensions)
                 // If slot is empty, push None (not an error - variable may not exist yet)
-                let idx = idx.get(arg) as usize;
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow_mut() }[idx]
                     .take()
                     .unwrap_or_else(|| vm.ctx.none());
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastCheck(idx) => {
+            Instruction::LoadFastCheck { var_num } => {
                 // Same as LoadFast but explicitly checks for unbound locals
                 // (LoadFast in RustPython already does this check)
-                let idx = idx.get(arg) as usize;
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow() }[idx]
                     .clone()
                     .ok_or_else(|| {
@@ -2092,10 +2090,10 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastLoadFast { arg: packed } => {
+            Instruction::LoadFastLoadFast { var_nums } => {
                 // Load two local variables at once
                 // oparg encoding: (idx1 << 4) | idx2
-                let oparg = packed.get(arg);
+                let oparg = var_nums.get(arg);
                 let idx1 = (oparg >> 4) as usize;
                 let idx2 = (oparg & 15) as usize;
                 let fastlocals = unsafe { self.fastlocals.borrow() };
@@ -2126,8 +2124,8 @@ impl ExecutingFrame<'_> {
             // Borrow optimization not yet active; falls back to clone.
             // push_borrowed() is available but disabled until stack
             // lifetime issues at yield/exception points are resolved.
-            Instruction::LoadFastBorrow(idx) => {
-                let idx = idx.get(arg) as usize;
+            Instruction::LoadFastBorrow { var_num } => {
+                let idx = var_num.get(arg) as usize;
                 let x = unsafe { self.fastlocals.borrow() }[idx]
                     .clone()
                     .ok_or_else(|| {
@@ -2143,8 +2141,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(x);
                 Ok(None)
             }
-            Instruction::LoadFastBorrowLoadFastBorrow { arg: packed } => {
-                let oparg = packed.get(arg);
+            Instruction::LoadFastBorrowLoadFastBorrow { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = (oparg >> 4) as usize;
                 let idx2 = (oparg & 15) as usize;
                 let fastlocals = unsafe { self.fastlocals.borrow() };
@@ -2172,8 +2170,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(x2);
                 Ok(None)
             }
-            Instruction::LoadGlobal(idx) => {
-                let oparg = idx.get(arg);
+            Instruction::LoadGlobal { namei } => {
+                let oparg = namei.get(arg);
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_cache_u16(cache_base);
@@ -2194,8 +2192,8 @@ impl ExecutingFrame<'_> {
                 }
                 Ok(None)
             }
-            Instruction::LoadName(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::LoadName { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 let result = self.locals.mapping(vm).subscript(name, vm);
                 match result {
                     Ok(x) => self.push_value(x),
@@ -2236,7 +2234,7 @@ impl ExecutingFrame<'_> {
                 Ok(None)
             }
             Instruction::MakeFunction => self.execute_make_function(vm),
-            Instruction::MakeCell(_) => {
+            Instruction::MakeCell { .. } => {
                 // Cell creation is handled at frame creation time in RustPython
                 Ok(None)
             }
@@ -2251,14 +2249,14 @@ impl ExecutingFrame<'_> {
                 dict.set_item(&*key, value, vm)?;
                 Ok(None)
             }
-            Instruction::MatchClass(nargs) => {
+            Instruction::MatchClass { count } => {
                 // 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 nargs_val = count.get(arg) as usize;
 
                 // Check if subject is an instance of cls
                 if subject.is_instance(cls.as_ref(), vm)? {
@@ -2529,7 +2527,7 @@ impl ExecutingFrame<'_> {
                 self.push_null();
                 Ok(None)
             }
-            Instruction::RaiseVarargs { kind } => self.execute_raise(vm, kind.get(arg)),
+            Instruction::RaiseVarargs { argc } => self.execute_raise(vm, argc.get(arg)),
             Instruction::Resume { .. } => {
                 // Lazy quickening: initialize adaptive counters on first execution
                 if !self.code.quickened.swap(true, atomic::Ordering::Relaxed) {
@@ -2655,11 +2653,11 @@ impl ExecutingFrame<'_> {
                     Err(exc)
                 }
             }
-            Instruction::SetFunctionAttribute { attr } => {
-                self.execute_set_function_attribute(vm, attr.get(arg))
+            Instruction::SetFunctionAttribute { flag } => {
+                self.execute_set_function_attribute(vm, flag.get(arg))
             }
             Instruction::SetupAnnotations => self.setup_annotations(vm),
-            Instruction::StoreAttr { idx } => {
+            Instruction::StoreAttr { namei } => {
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_cache_u16(cache_base);
@@ -2670,19 +2668,19 @@ impl ExecutingFrame<'_> {
                             .write_cache_u16(cache_base, counter - 1);
                     }
                 } else {
-                    self.specialize_store_attr(vm, idx.get(arg), instr_idx, cache_base);
+                    self.specialize_store_attr(vm, namei.get(arg), instr_idx, cache_base);
                 }
-                self.store_attr(vm, idx.get(arg))
+                self.store_attr(vm, namei.get(arg))
             }
-            Instruction::StoreDeref(i) => {
+            Instruction::StoreDeref { i } => {
                 let value = self.pop_value();
                 self.state.cells_frees[i.get(arg) as usize].set(Some(value));
                 Ok(None)
             }
-            Instruction::StoreFast(idx) => {
+            Instruction::StoreFast { var_num } => {
                 let value = self.pop_value();
                 let fastlocals = unsafe { self.fastlocals.borrow_mut() };
-                fastlocals[idx.get(arg) as usize] = Some(value);
+                fastlocals[var_num.get(arg) as usize] = Some(value);
                 Ok(None)
             }
             Instruction::StoreFastLoadFast { var_nums } => {
@@ -2696,8 +2694,8 @@ impl ExecutingFrame<'_> {
                 self.push_value(load_value);
                 Ok(None)
             }
-            Instruction::StoreFastStoreFast { arg: packed } => {
-                let oparg = packed.get(arg);
+            Instruction::StoreFastStoreFast { var_nums } => {
+                let oparg = var_nums.get(arg);
                 let idx1 = (oparg >> 4) as usize;
                 let idx2 = (oparg & 15) as usize;
                 let value1 = self.pop_value();
@@ -2707,14 +2705,14 @@ impl ExecutingFrame<'_> {
                 fastlocals[idx2] = Some(value2);
                 Ok(None)
             }
-            Instruction::StoreGlobal(idx) => {
+            Instruction::StoreGlobal { namei } => {
                 let value = self.pop_value();
                 self.globals
-                    .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
+                    .set_item(self.code.names[namei.get(arg) as usize], value, vm)?;
                 Ok(None)
             }
-            Instruction::StoreName(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
+            Instruction::StoreName { namei } => {
+                let name = self.code.names[namei.get(arg) as usize];
                 let value = self.pop_value();
                 self.locals
                     .mapping(vm)
@@ -2752,7 +2750,7 @@ impl ExecutingFrame<'_> {
                 }
                 self.execute_store_subscript(vm)
             }
-            Instruction::Swap { index } => {
+            Instruction::Swap { i: index } => {
                 let len = self.state.stack.len();
                 debug_assert!(len > 0, "stack underflow in SWAP");
                 let i = len - 1; // TOS index
@@ -2787,11 +2785,11 @@ impl ExecutingFrame<'_> {
                 self.push_value(vm.ctx.new_bool(bool_val).into());
                 Ok(None)
             }
-            Instruction::UnpackEx { args } => {
-                let args = args.get(arg);
+            Instruction::UnpackEx { counts } => {
+                let args = counts.get(arg);
                 self.execute_unpack_ex(vm, args.before, args.after)
             }
-            Instruction::UnpackSequence { size } => {
+            Instruction::UnpackSequence { count } => {
                 let instr_idx = self.lasti() as usize - 1;
                 let cache_base = instr_idx + 1;
                 let counter = self.code.instructions.read_cache_u16(cache_base);
@@ -2804,7 +2802,7 @@ impl ExecutingFrame<'_> {
                 } else {
                     self.specialize_unpack_sequence(vm, instr_idx, cache_base);
                 }
-                self.unpack_sequence(size.get(arg), vm)
+                self.unpack_sequence(count.get(arg), vm)
             }
             Instruction::WithExceptStart => {
                 // Stack: [..., __exit__, lasti, prev_exc, exc]
@@ -2918,7 +2916,7 @@ impl ExecutingFrame<'_> {
                     self.code.instructions.replace_op(
                         instr_idx,
                         Instruction::Send {
-                            target: Arg::marker(),
+                            delta: Arg::marker(),
                         },
                     );
                     self.code
@@ -3037,9 +3035,12 @@ impl ExecutingFrame<'_> {
                 } else {
                     // De-optimize
                     unsafe {
-                        self.code
-                            .instructions
-                            .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                        self.code.instructions.replace_op(
+                            instr_idx,
+                            Instruction::LoadAttr {
+                                namei: Arg::marker(),
+                            },
+                        );
                         self.code
                             .instructions
                             .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3067,7 +3068,9 @@ impl ExecutingFrame<'_> {
                                 unsafe {
                                     self.code.instructions.replace_op(
                                         instr_idx,
-                                        Instruction::LoadAttr { idx: Arg::marker() },
+                                        Instruction::LoadAttr {
+                                            namei: Arg::marker(),
+                                        },
                                     );
                                     self.code
                                         .instructions
@@ -3092,9 +3095,12 @@ impl ExecutingFrame<'_> {
                 }
                 // De-optimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3124,9 +3130,12 @@ impl ExecutingFrame<'_> {
                 }
                 // De-optimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3158,9 +3167,12 @@ impl ExecutingFrame<'_> {
                 }
                 // Deoptimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3189,9 +3201,12 @@ impl ExecutingFrame<'_> {
                     return Ok(None);
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3234,9 +3249,12 @@ impl ExecutingFrame<'_> {
                     return Ok(None);
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3267,9 +3285,12 @@ impl ExecutingFrame<'_> {
                     return Ok(None);
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3300,9 +3321,12 @@ impl ExecutingFrame<'_> {
                     // Slot is None → AttributeError (fall through to slow path)
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3332,9 +3356,12 @@ impl ExecutingFrame<'_> {
                     }
                 }
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::LoadAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::LoadAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3360,9 +3387,12 @@ impl ExecutingFrame<'_> {
                 }
                 // Deoptimize
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::StoreAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::StoreAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3389,9 +3419,12 @@ impl ExecutingFrame<'_> {
                 // Deoptimize
                 let attr_idx = u32::from(arg);
                 unsafe {
-                    self.code
-                        .instructions
-                        .replace_op(instr_idx, Instruction::StoreAttr { idx: Arg::marker() });
+                    self.code.instructions.replace_op(
+                        instr_idx,
+                        Instruction::StoreAttr {
+                            namei: Arg::marker(),
+                        },
+                    );
                     self.code
                         .instructions
                         .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -3689,7 +3722,7 @@ impl ExecutingFrame<'_> {
                         self.code.instructions.replace_op(
                             instr_idx,
                             Instruction::Call {
-                                nargs: Arg::marker(),
+                                argc: Arg::marker(),
                             },
                         );
                         self.code
@@ -3727,7 +3760,7 @@ impl ExecutingFrame<'_> {
                         self.code.instructions.replace_op(
                             instr_idx,
                             Instruction::Call {
-                                nargs: Arg::marker(),
+                                argc: Arg::marker(),
                             },
                         );
                         self.code
@@ -4348,7 +4381,9 @@ impl ExecutingFrame<'_> {
                 unsafe {
                     self.code.instructions.replace_op(
                         self.lasti() as usize - 1,
-                        Instruction::LoadSuperAttr { arg: Arg::marker() },
+                        Instruction::LoadSuperAttr {
+                            namei: Arg::marker(),
+                        },
                     );
                     let cache_base = self.lasti() as usize;
                     self.code
@@ -4426,7 +4461,9 @@ impl ExecutingFrame<'_> {
                 unsafe {
                     self.code.instructions.replace_op(
                         self.lasti() as usize - 1,
-                        Instruction::LoadSuperAttr { arg: Arg::marker() },
+                        Instruction::LoadSuperAttr {
+                            namei: Arg::marker(),
+                        },
                     );
                     let cache_base = self.lasti() as usize;
                     self.code
@@ -7025,9 +7062,12 @@ impl ExecutingFrame<'_> {
         let instr_idx = self.lasti() as usize - 1;
         let cache_base = instr_idx + 1;
         unsafe {
-            self.code
-                .instructions
-                .replace_op(instr_idx, Instruction::CompareOp { op: Arg::marker() });
+            self.code.instructions.replace_op(
+                instr_idx,
+                Instruction::CompareOp {
+                    opname: Arg::marker(),
+                },
+            );
             self.code
                 .instructions
                 .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -7119,7 +7159,7 @@ impl ExecutingFrame<'_> {
             self.code.instructions.replace_op(
                 instr_idx,
                 Instruction::Call {
-                    nargs: Arg::marker(),
+                    argc: Arg::marker(),
                 },
             );
             self.code
@@ -7135,7 +7175,7 @@ impl ExecutingFrame<'_> {
             self.code.instructions.replace_op(
                 instr_idx,
                 Instruction::CallKw {
-                    nargs: Arg::marker(),
+                    argc: Arg::marker(),
                 },
             );
             self.code
@@ -7151,7 +7191,7 @@ impl ExecutingFrame<'_> {
             self.code.instructions.replace_op(
                 instr_idx,
                 Instruction::ForIter {
-                    target: Arg::marker(),
+                    delta: Arg::marker(),
                 },
             );
             self.code
@@ -7225,9 +7265,12 @@ impl ExecutingFrame<'_> {
         let instr_idx = self.lasti() as usize - 1;
         let cache_base = instr_idx + 1;
         unsafe {
-            self.code
-                .instructions
-                .replace_op(instr_idx, Instruction::LoadGlobal(Arg::marker()));
+            self.code.instructions.replace_op(
+                instr_idx,
+                Instruction::LoadGlobal {
+                    namei: Arg::marker(),
+                },
+            );
             self.code
                 .instructions
                 .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -7307,9 +7350,12 @@ impl ExecutingFrame<'_> {
         let instr_idx = self.lasti() as usize - 1;
         let cache_base = instr_idx + 1;
         unsafe {
-            self.code
-                .instructions
-                .replace_op(instr_idx, Instruction::ContainsOp(Arg::marker()));
+            self.code.instructions.replace_op(
+                instr_idx,
+                Instruction::ContainsOp {
+                    invert: Arg::marker(),
+                },
+            );
             self.code
                 .instructions
                 .write_adaptive_counter(cache_base, ADAPTIVE_BACKOFF_VALUE);
@@ -7355,7 +7401,7 @@ impl ExecutingFrame<'_> {
             self.code.instructions.replace_op(
                 instr_idx,
                 Instruction::UnpackSequence {
-                    size: Arg::marker(),
+                    count: Arg::marker(),
                 },
             );
             self.code