diff --git a/crates/codegen/src/backend/evm/assembler/mod.rs b/crates/codegen/src/backend/evm/assembler/mod.rs
index cf8fb8128..c18f89cb1 100644
--- a/crates/codegen/src/backend/evm/assembler/mod.rs
+++ b/crates/codegen/src/backend/evm/assembler/mod.rs
@@ -85,6 +85,8 @@ pub(crate) struct Assembler<'gcx> {
     label_relocations: Vec<(ir::BlockId, usize, Label)>,
     /// Unresolved deferred constants emitted as push operands.
     deferred_relocations: Vec<(ir::BlockId, usize, DeferredConst)>,
+    /// Indexed jumps whose possible targets are assembler labels.
+    indexed_jump_relocations: Vec<(ir::BlockId, Vec<Label>)>,
     /// Interned push immediates too large for inline storage.
     push_values: LocalInterner<U256, PushValueId>,
     /// Next label ID.
@@ -121,6 +123,7 @@ impl<'gcx> Assembler<'gcx> {
             cold_labels: GrowableBitSet::new_empty(),
             label_relocations: Vec::new(),
             deferred_relocations: Vec::new(),
+            indexed_jump_relocations: Vec::new(),
             push_values: LocalInterner::new(),
             next_label: IdCounter::new(),
             next_deferred: IdCounter::new(),
@@ -140,6 +143,7 @@ impl<'gcx> Assembler<'gcx> {
         self.cold_labels.clear();
         self.label_relocations.clear();
         self.deferred_relocations.clear();
+        self.indexed_jump_relocations.clear();
         self.push_values.clear();
         self.next_label.clear();
         self.next_deferred.clear();
@@ -176,6 +180,13 @@ impl<'gcx> Assembler<'gcx> {
         self.label_relocations.push((block, instruction, label));
     }
 
+    /// Terminates the current block with an indexed jump to one of `targets`.
+    pub(crate) fn emit_indexed_jump(&mut self, targets: Vec<Label>) {
+        assert!(!targets.is_empty(), "indexed jump must have at least one target");
+        let block = self.current_block();
+        self.indexed_jump_relocations.push((block, targets));
+    }
+
     /// Emits a push instruction for a deferred constant.
     pub(crate) fn emit_push_deferred(&mut self, id: DeferredConst) {
         let (block, instruction) =
@@ -322,10 +333,23 @@ impl<'gcx> Assembler<'gcx> {
             module.blocks[block].instructions.splice(instruction..=instruction, replacement);
         }
         self.deferred_allocations.clear();
+        Self::finalize_evm_ir(&mut module);
+        for (block, targets) in self.indexed_jump_relocations.drain(..) {
+            let targets = targets
+                .into_iter()
+                .map(|label| {
+                    self.label_blocks
+                        .get(&label)
+                        .copied()
+                        .unwrap_or_else(|| panic!("label {label:?} was never defined"))
+                })
+                .collect::<Vec<_>>()
+                .into_boxed_slice();
+            module.blocks[block].terminator =
+                Some(ir::Terminator::new(ir::TerminatorKind::IndexedJump(targets)));
+        }
         self.label_blocks.clear();
         self.cold_labels.clear();
-
-        Self::finalize_evm_ir(&mut module);
         Some((module, std::mem::take(&mut self.block_labels)))
     }
 
@@ -396,8 +420,13 @@ impl<'gcx> Assembler<'gcx> {
             debug_assert!(!input_is_valid || is_valid_evm_ir(&ir_program));
         }
 
+        let program = assembly::lower_evm_ir(
+            &mut ir_program,
+            &mut labels,
+            self,
+            self.gcx.sess.opts.evm_version,
+        );
         let evm_ir = capture_evm_ir.then(|| ir_program.clone());
-        let program = assembly::lower_evm_ir(&ir_program, &mut labels, self);
         PreparedAssembly {
             evm_ir,
             program,
@@ -460,11 +489,14 @@ impl<'gcx> Assembler<'gcx> {
 
         // Label-free constructor and deployment snippets need neither offset
         // discovery nor push-width relaxation.
-        if !program
-            .instructions
-            .iter()
-            .any(|inst| matches!(inst.kind(), AsmInstKind::Label(_) | AsmInstKind::PushLabel(_)))
-        {
+        if !program.instructions.iter().any(|inst| {
+            matches!(
+                inst.kind(),
+                AsmInstKind::Label(_)
+                    | AsmInstKind::PushLabel(_)
+                    | AsmInstKind::PushLabelFixed(_, _)
+            )
+        }) {
             let mut result =
                 self.emit_bytecode(&program, FxHashMap::default(), &FxHashMap::default());
             result.evm_ir = evm_ir;
@@ -525,6 +557,9 @@ impl<'gcx> Assembler<'gcx> {
                     let width = push_widths.get(&idx).copied().unwrap_or(2);
                     offset += out.fixed_push_len(width);
                 }
+                AsmInstKind::PushLabelFixed(_, width) => {
+                    offset += out.fixed_push_len(width);
+                }
                 AsmInstKind::PushDeferred(_) => {
                     unreachable!("deferred values must be resolved before assembly");
                 }
@@ -538,7 +573,6 @@ impl<'gcx> Assembler<'gcx> {
                 }
             }
         }
-
         // Compute new widths based on resolved offsets
         for (idx, inst) in program.instructions.iter().enumerate() {
             if let AsmInstKind::PushLabel(label) = inst.kind()
@@ -580,6 +614,13 @@ impl<'gcx> Assembler<'gcx> {
                     let width = push_widths.get(&idx).copied().unwrap_or(2);
                     out.emit_push_fixed_width(U256::from(target_offset), width);
                 }
+                AsmInstKind::PushLabelFixed(label, width) => {
+                    let target_offset = label_offsets
+                        .get(&label)
+                        .copied()
+                        .unwrap_or_else(|| panic!("label {label:?} was never defined"));
+                    out.emit_push_fixed_width(U256::from(target_offset), width);
+                }
                 AsmInstKind::PushDeferred(_) => {
                     unreachable!("deferred values must be resolved before assembly");
                 }
@@ -591,7 +632,6 @@ impl<'gcx> Assembler<'gcx> {
                 }
             }
         }
-
         out.finish()
     }
 
@@ -641,6 +681,7 @@ impl<'gcx> BytecodeAssembler<'gcx> {
 
     /// Emits a PUSH instruction with a specific width.
     fn emit_push_fixed_width(&mut self, value: U256, width: u8) {
+        assert!(self.push_width(value) <= width, "value does not fit fixed PUSH width");
         if width == 0 {
             self.emit_push_zero();
             return;
@@ -791,6 +832,44 @@ PUSH4 0x80000000
                 str![[r#"
 PUSH1 0x02
 
+"#]]
+            );
+        });
+    }
+
+    #[test]
+    fn indexed_jump_uses_reachable_fixed_stride_blocks() {
+        with_assembler(opts(EvmVersion::Shanghai, OptimizationMode::None), |mut asm| {
+            let left = asm.new_label();
+            let right = asm.new_label();
+
+            asm.emit_push(U256::from(1));
+            asm.emit_indexed_jump(vec![left, right]);
+            asm.define_label(left);
+            asm.emit_op(op::STOP);
+            asm.define_label(right);
+            asm.emit_op(op::INVALID);
+
+            assert_data_eq!(
+                disassemble(&asm.assemble().bytecode),
+                str![[r#"
+PUSH1 0x01
+PUSH1 0x04
+MUL
+PUSH1 0x0d
+ADD
+JUMP
+JUMPDEST
+STOP
+JUMPDEST
+INVALID
+JUMPDEST
+PUSH1 0x09
+JUMP
+JUMPDEST
+PUSH1 0x0b
+JUMP
+
 "#]]
             );
         });
diff --git a/crates/codegen/src/backend/evm/codegen.rs b/crates/codegen/src/backend/evm/codegen.rs
index 7f6a7a493..833eaebc1 100644
--- a/crates/codegen/src/backend/evm/codegen.rs
+++ b/crates/codegen/src/backend/evm/codegen.rs
@@ -14,6 +14,7 @@ use super::{
     stack::{
         MAX_STACK_ACCESS, ScheduledOp, SpillSlot, StackModel, StackOp, StackScheduler, TargetSlot,
     },
+    switch::{SwitchPlan, bucket_index, select_switch_plan},
 };
 use crate::{
     analysis::{
@@ -26,7 +27,7 @@ use crate::{
     transform::{eligible_static_allocations, lower_alloc_except},
 };
 use alloy_primitives::U256;
-use solar_config::OptimizationMode;
+use solar_config::{EvmVersion, OptimizationMode};
 use solar_data_structures::{
     bit_set::{DenseBitSet, GrowableBitSet},
     map::{FxHashMap, FxHashSet},
@@ -34,8 +35,6 @@ use solar_data_structures::{
 use solar_interface::{Span, sym};
 use solar_sema::{Gcx, hir::StateMutability};
 use std::sync::Arc;
-
-const LINEAR_SELECTOR_DISPATCH_THRESHOLD: usize = 64;
 const STACK_PHI_LAYOUT_LIMIT: usize = 8;
 const GLOBAL_STACK_LAYOUT_LIMIT: usize = 8;
 const GLOBAL_STACK_MAX_ARGS: usize = 3;
@@ -97,6 +96,13 @@ struct SelectorDispatchEntry {
     label: Label,
 }
 
+#[derive(Clone, Copy, Debug)]
+struct MirSwitchEntry {
+    value: U256,
+    value_id: ValueId,
+    target: BlockId,
+}
+
 #[derive(Clone, Debug, Default)]
 struct StackPhiPlan {
     entries: FxHashMap<BlockId, Vec<ValueId>>,
@@ -1488,16 +1494,55 @@ impl<'gcx> EvmCodegen<'gcx> {
         !func.attributes.is_constructor
     }
 
+    fn switch_table_target_width(&self) -> usize {
+        if self.in_constructor && self.gcx.sess.opts.evm_version < EvmVersion::Shanghai {
+            3
+        } else {
+            2
+        }
+    }
+
     fn emit_selector_dispatch(
         &mut self,
         selectors: &[SelectorDispatchEntry],
         fallback_label: Option<Label>,
         revert_label: Label,
     ) {
-        if selectors.len() <= LINEAR_SELECTOR_DISPATCH_THRESHOLD {
-            self.emit_linear_selector_dispatch(selectors, fallback_label, revert_label);
-        } else {
-            self.emit_binary_selector_dispatch(selectors, fallback_label, revert_label);
+        let values: Vec<_> = selectors.iter().map(|entry| U256::from(entry.selector)).collect();
+        match select_switch_plan(
+            &values,
+            self.gcx.sess.opts.optimization,
+            self.gcx.sess.opts.evm_version,
+            false,
+            self.switch_table_target_width(),
+        ) {
+            SwitchPlan::Linear => {
+                self.emit_linear_selector_dispatch(selectors, fallback_label, revert_label);
+            }
+            SwitchPlan::Binary { leaf_size } => {
+                self.emit_binary_selector_dispatch(
+                    selectors,
+                    fallback_label,
+                    revert_label,
+                    leaf_size,
+                );
+            }
+            SwitchPlan::Buckets { bucket_count } => {
+                self.emit_bucketed_selector_dispatch(
+                    selectors,
+                    fallback_label,
+                    revert_label,
+                    bucket_count,
+                );
+            }
+            SwitchPlan::Dense { low, range } => {
+                self.emit_dense_selector_dispatch(
+                    selectors,
+                    fallback_label.unwrap_or(revert_label),
+                    low,
+                    range,
+                );
+            }
         }
     }
 
@@ -1518,8 +1563,9 @@ impl<'gcx> EvmCodegen<'gcx> {
         selectors: &[SelectorDispatchEntry],
         fallback_label: Option<Label>,
         revert_label: Label,
+        leaf_size: usize,
     ) {
-        if selectors.len() <= LINEAR_SELECTOR_DISPATCH_THRESHOLD {
+        if selectors.len() <= leaf_size {
             self.emit_linear_selector_dispatch(selectors, fallback_label, revert_label);
             return;
         }
@@ -1535,16 +1581,96 @@ impl<'gcx> EvmCodegen<'gcx> {
         self.asm.emit_push_label(left_label);
         self.asm.emit_op(op::JUMPI);
 
-        self.emit_binary_selector_dispatch(&selectors[mid..], fallback_label, revert_label);
+        self.emit_binary_selector_dispatch(
+            &selectors[mid..],
+            fallback_label,
+            revert_label,
+            leaf_size,
+        );
 
         self.asm.define_label(left_label);
-        self.emit_binary_selector_dispatch(&selectors[..mid], fallback_label, revert_label);
+        self.emit_binary_selector_dispatch(
+            &selectors[..mid],
+            fallback_label,
+            revert_label,
+            leaf_size,
+        );
+    }
+
+    fn emit_bucketed_selector_dispatch(
+        &mut self,
+        selectors: &[SelectorDispatchEntry],
+        fallback_label: Option<Label>,
+        revert_label: Label,
+        bucket_count: usize,
+    ) {
+        let mut buckets = vec![Vec::new(); bucket_count];
+        for &entry in selectors {
+            buckets[bucket_index(U256::from(entry.selector), bucket_count)].push(entry);
+        }
+        let default_label = fallback_label.unwrap_or(revert_label);
+        let bucket_labels: Vec<_> = buckets
+            .iter()
+            .map(|bucket| if bucket.is_empty() { default_label } else { self.asm.new_label() })
+            .collect();
+
+        self.asm.emit_op(op::DUP1);
+        self.asm.emit_push(U256::from(bucket_count));
+        self.asm.emit_op(op::SWAP1);
+        self.asm.emit_op(op::MOD);
+        self.asm.emit_indexed_jump(bucket_labels.clone());
+
+        for (label, bucket) in bucket_labels.into_iter().zip(buckets) {
+            if bucket.is_empty() {
+                continue;
+            }
+            self.asm.define_label(label);
+            self.emit_linear_selector_dispatch(&bucket, fallback_label, revert_label);
+        }
+    }
+
+    fn emit_dense_selector_dispatch(
+        &mut self,
+        selectors: &[SelectorDispatchEntry],
+        default_label: Label,
+        low: U256,
+        range: usize,
+    ) {
+        let mut targets = vec![default_label; range];
+        for entry in selectors {
+            let index = usize::try_from(U256::from(entry.selector) - low)
+                .expect("dense selector table index must fit usize");
+            targets[index] = entry.label;
+        }
+        let in_range = self.asm.new_label();
+
+        if !low.is_zero() {
+            self.asm.emit_push(low);
+            self.asm.emit_op(op::SWAP1);
+            self.asm.emit_op(op::SUB);
+        }
+        self.asm.emit_op(op::DUP1);
+        self.asm.emit_push(U256::from(range));
+        self.asm.emit_op(op::SWAP1);
+        self.asm.emit_op(op::LT);
+        self.asm.emit_push_label(in_range);
+        self.asm.emit_op(op::JUMPI);
+        self.asm.emit_op(op::POP);
+        self.asm.emit_push_label(default_label);
+        self.asm.emit_op(op::JUMP);
+
+        self.asm.define_label(in_range);
+        self.asm.emit_indexed_jump(targets);
     }
 
     fn emit_selector_eq_jump(&mut self, entry: SelectorDispatchEntry) {
         self.asm.emit_op(op::dup(1));
-        self.asm.emit_push(U256::from(entry.selector));
-        self.asm.emit_op(op::EQ);
+        if entry.selector == 0 && self.gcx.sess.opts.optimization != OptimizationMode::None {
+            self.asm.emit_op(op::ISZERO);
+        } else {
+            self.asm.emit_push(U256::from(entry.selector));
+            self.asm.emit_op(op::EQ);
+        }
         self.asm.emit_push_label(entry.label);
         self.asm.emit_op(op::JUMPI);
     }
@@ -5296,6 +5422,209 @@ impl<'gcx> EvmCodegen<'gcx> {
         }
     }
 
+    fn constant_switch_entries(
+        &self,
+        func: &Function,
+        cases: &[(ValueId, BlockId)],
+    ) -> Option<Vec<MirSwitchEntry>> {
+        let mut entries = cases
+            .iter()
+            .map(|&(value_id, target)| {
+                let value = func.value(value_id).as_immediate()?.as_u256()?;
+                Some(MirSwitchEntry { value, value_id, target })
+            })
+            .collect::<Option<Vec<_>>>()?;
+        entries.sort_unstable_by_key(|entry| entry.value);
+        if entries.windows(2).any(|entries| entries[0].value == entries[1].value) {
+            return None;
+        }
+        Some(entries)
+    }
+
+    fn emit_linear_mir_switch(&mut self, func: &Function, cases: &[(ValueId, BlockId)]) {
+        for &(value_id, target) in cases {
+            let value = func.value(value_id).as_immediate().and_then(|value| value.as_u256());
+            self.emit_mir_switch_eq_jump(func, value_id, value, target);
+        }
+    }
+
+    fn emit_binary_mir_switch(
+        &mut self,
+        func: &Function,
+        entries: &[MirSwitchEntry],
+        default: BlockId,
+        can_fallthrough: bool,
+        leaf_size: usize,
+    ) {
+        if entries.len() <= leaf_size {
+            for entry in entries {
+                self.emit_mir_switch_eq_jump(func, entry.value_id, Some(entry.value), entry.target);
+            }
+            self.emit_mir_switch_default(default, can_fallthrough);
+            return;
+        }
+
+        let mid = entries.len() / 2;
+        let left_label = self.asm.new_label();
+        let entry_stack = self.scheduler.stack.clone();
+
+        // With the pivot on top, GT computes `pivot > selector`.
+        self.asm.emit_op(op::DUP1);
+        self.scheduler.stack.dup(1);
+        self.emit_operand(func, entries[mid].value_id);
+        self.asm.emit_op(op::GT);
+        self.scheduler.instruction_executed_untracked(2);
+        self.asm.emit_push_label(left_label);
+        self.asm.emit_op(op::JUMPI);
+        self.scheduler.instruction_executed(1, None);
+
+        self.emit_binary_mir_switch(func, &entries[mid..], default, false, leaf_size);
+
+        self.asm.define_label(left_label);
+        self.scheduler.stack = entry_stack;
+        self.emit_binary_mir_switch(func, &entries[..mid], default, can_fallthrough, leaf_size);
+    }
+
+    fn emit_bucketed_mir_switch(
+        &mut self,
+        func: &Function,
+        entries: &[MirSwitchEntry],
+        default: BlockId,
+        can_fallthrough: bool,
+        bucket_count: usize,
+    ) {
+        let mut buckets = vec![Vec::new(); bucket_count];
+        for &entry in entries {
+            buckets[bucket_index(entry.value, bucket_count)].push(entry);
+        }
+        let default_label = self.block_labels[&default];
+        let empty_label = (!self.emitting_dispatch_entry
+            && buckets.iter().any(|bucket| bucket.is_empty()))
+        .then(|| self.asm.new_label());
+        let bucket_labels: Vec<_> = buckets
+            .iter()
+            .map(|bucket| {
+                if bucket.is_empty() {
+                    empty_label.unwrap_or(default_label)
+                } else {
+                    self.asm.new_label()
+                }
+            })
+            .collect();
+
+        self.asm.emit_op(op::DUP1);
+        self.scheduler.stack.dup(1);
+        self.asm.emit_push(U256::from(bucket_count));
+        self.scheduler.stack.push_unknown();
+        self.asm.emit_op(op::SWAP1);
+        self.scheduler.stack_swapped();
+        self.asm.emit_op(op::MOD);
+        self.scheduler.instruction_executed_untracked(2);
+        self.asm.emit_indexed_jump(bucket_labels.clone());
+        self.scheduler.stack.pop();
+
+        let entry_stack = self.scheduler.stack.clone();
+        if let Some(empty_label) = empty_label {
+            self.asm.define_label(empty_label);
+            self.scheduler.stack = entry_stack.clone();
+            self.emit_mir_switch_default(default, false);
+        }
+        let last_bucket = buckets.iter().rposition(|bucket| !bucket.is_empty()).unwrap();
+        for (index, (label, bucket)) in bucket_labels.into_iter().zip(buckets).enumerate() {
+            if bucket.is_empty() {
+                continue;
+            }
+            self.asm.define_label(label);
+            self.scheduler.stack = entry_stack.clone();
+            for entry in bucket {
+                self.emit_mir_switch_eq_jump(func, entry.value_id, Some(entry.value), entry.target);
+            }
+            self.emit_mir_switch_default(default, can_fallthrough && index == last_bucket);
+        }
+    }
+
+    fn emit_dense_mir_switch(
+        &mut self,
+        entries: &[MirSwitchEntry],
+        default: BlockId,
+        low: U256,
+        range: usize,
+    ) {
+        let mut targets = vec![self.block_labels[&default]; range];
+        for entry in entries {
+            let index = usize::try_from(entry.value - low)
+                .expect("dense switch table index must fit usize");
+            targets[index] = self.block_labels[&entry.target];
+        }
+        let in_range = self.asm.new_label();
+
+        if !low.is_zero() {
+            self.asm.emit_push(low);
+            self.scheduler.stack.push_unknown();
+            self.asm.emit_op(op::SWAP1);
+            self.scheduler.stack_swapped();
+            self.asm.emit_op(op::SUB);
+            self.scheduler.instruction_executed_untracked(2);
+        }
+        self.asm.emit_op(op::DUP1);
+        self.scheduler.stack.dup(1);
+        self.asm.emit_push(U256::from(range));
+        self.scheduler.stack.push_unknown();
+        self.asm.emit_op(op::SWAP1);
+        self.scheduler.stack_swapped();
+        self.asm.emit_op(op::LT);
+        self.scheduler.instruction_executed_untracked(2);
+        self.asm.emit_push_label(in_range);
+        self.asm.emit_op(op::JUMPI);
+        self.scheduler.instruction_executed(1, None);
+
+        let indexed_stack = self.scheduler.stack.clone();
+        self.asm.emit_op(op::POP);
+        self.scheduler.stack.pop();
+        self.asm.emit_push_label(self.block_labels[&default]);
+        self.asm.emit_op(op::JUMP);
+
+        self.asm.define_label(in_range);
+        self.scheduler.stack = indexed_stack;
+        self.asm.emit_indexed_jump(targets);
+        self.scheduler.stack.pop();
+    }
+
+    fn emit_mir_switch_eq_jump(
+        &mut self,
+        func: &Function,
+        value_id: ValueId,
+        value: Option<U256>,
+        target: BlockId,
+    ) {
+        self.asm.emit_op(op::DUP1);
+        self.scheduler.stack.dup(1);
+        if value.is_some_and(|value| value.is_zero())
+            && self.gcx.sess.opts.optimization != OptimizationMode::None
+        {
+            self.asm.emit_op(op::ISZERO);
+            self.scheduler.instruction_executed_untracked(1);
+        } else {
+            self.emit_operand(func, value_id);
+            self.asm.emit_op(op::EQ);
+            self.scheduler.instruction_executed_untracked(2);
+        }
+        self.asm.emit_push_label(self.block_labels[&target]);
+        self.asm.emit_op(op::JUMPI);
+        self.scheduler.instruction_executed(1, None);
+    }
+
+    fn emit_mir_switch_default(&mut self, default: BlockId, can_fallthrough: bool) {
+        if !self.emitting_dispatch_entry {
+            self.asm.emit_op(op::POP);
+            self.scheduler.stack.pop();
+        }
+        if !can_fallthrough {
+            self.asm.emit_push_label(self.block_labels[&default]);
+            self.asm.emit_op(op::JUMP);
+        }
+    }
+
     /// Generates bytecode for a terminator.
     fn generate_terminator(
         &mut self,
@@ -5417,6 +5746,18 @@ impl<'gcx> EvmCodegen<'gcx> {
             }
 
             Terminator::Switch { value, default, cases } => {
+                let constant_entries = self.constant_switch_entries(func, cases);
+                let plan = constant_entries.as_ref().map_or(SwitchPlan::Linear, |entries| {
+                    let values: Vec<_> = entries.iter().map(|entry| entry.value).collect();
+                    select_switch_plan(
+                        &values,
+                        self.gcx.sess.opts.optimization,
+                        self.gcx.sess.opts.evm_version,
+                        !self.emitting_dispatch_entry,
+                        self.switch_table_target_width(),
+                    )
+                });
+
                 if self.emitting_dispatch_entry {
                     // The dispatch entry's selector switch mirrors the backend
                     // dispatcher's shape: the just-computed selector stays on
@@ -5445,26 +5786,32 @@ impl<'gcx> EvmCodegen<'gcx> {
                     self.emit_value(func, *value);
                 }
 
-                for (case_val, target) in cases {
-                    // DUP the value, compare, jump if equal
-                    self.asm.emit_op(op::DUP1);
-                    self.scheduler.stack.dup(1);
-                    self.emit_operand(func, *case_val);
-                    self.asm.emit_op(op::EQ);
-                    self.scheduler.instruction_executed_untracked(2);
-                    self.asm.emit_push_label(self.block_labels[target]);
-                    self.asm.emit_op(op::JUMPI);
-                    self.scheduler.instruction_executed(1, None); // JUMPI consumes condition
-                }
-
-                if !self.emitting_dispatch_entry {
-                    // Pop the value before the default edge.
-                    self.asm.emit_op(op::POP);
-                    self.scheduler.stack.pop();
-                }
-                if Some(*default) != fallthrough {
-                    self.asm.emit_push_label(self.block_labels[default]);
-                    self.asm.emit_op(op::JUMP);
+                match (plan, constant_entries) {
+                    (SwitchPlan::Binary { leaf_size }, Some(entries)) => {
+                        self.emit_binary_mir_switch(
+                            func,
+                            &entries,
+                            *default,
+                            fallthrough == Some(*default),
+                            leaf_size,
+                        );
+                    }
+                    (SwitchPlan::Buckets { bucket_count }, Some(entries)) => {
+                        self.emit_bucketed_mir_switch(
+                            func,
+                            &entries,
+                            *default,
+                            fallthrough == Some(*default),
+                            bucket_count,
+                        );
+                    }
+                    (SwitchPlan::Dense { low, range }, Some(entries)) => {
+                        self.emit_dense_mir_switch(&entries, *default, low, range);
+                    }
+                    _ => {
+                        self.emit_linear_mir_switch(func, cases);
+                        self.emit_mir_switch_default(*default, fallthrough == Some(*default));
+                    }
                 }
             }
 
diff --git a/crates/codegen/src/backend/evm/ir/assembly/inst.rs b/crates/codegen/src/backend/evm/ir/assembly/inst.rs
index e15e0d473..f9adb69f4 100644
--- a/crates/codegen/src/backend/evm/ir/assembly/inst.rs
+++ b/crates/codegen/src/backend/evm/ir/assembly/inst.rs
@@ -65,6 +65,9 @@ impl AsmInst {
     const TAG_PUSH_DEFERRED: u32 = 0xb000_0000;
     const TAG_PUSH_IMMUTABLE: u32 = 0xc000_0000;
     const TAG_LABEL: u32 = 0xd000_0000;
+    const TAG_PUSH_LABEL_FIXED: u32 = 0xe000_0000;
+    const FIXED_LABEL_MASK: u32 = 0x007f_ffff;
+    const FIXED_WIDTH_SHIFT: u32 = 23;
 
     pub(in crate::backend::evm) fn op(opcode: u8) -> Self {
         Self(Self::TAG_OP | u32::from(opcode))
@@ -82,6 +85,14 @@ impl AsmInst {
         Self::tagged(Self::TAG_PUSH_LABEL, label.inst_payload())
     }
 
+    pub(in crate::backend::evm) fn push_label_fixed(label: Label, width: u8) -> Self {
+        assert!((1..=32).contains(&width), "invalid fixed label width");
+        let label = label.inst_payload();
+        assert!(label <= Self::FIXED_LABEL_MASK, "assembler label index overflow");
+        let width = u32::from(width - 1) << Self::FIXED_WIDTH_SHIFT;
+        Self::tagged(Self::TAG_PUSH_LABEL_FIXED, width | label)
+    }
+
     pub(in crate::backend::evm) fn push_deferred(id: DeferredConst) -> Self {
         Self::tagged(Self::TAG_PUSH_DEFERRED, id.inst_payload())
     }
@@ -114,6 +125,11 @@ impl AsmInst {
             }
             Self::TAG_PUSH_IMMUTABLE => AsmInstKind::PushImmutable(payload),
             Self::TAG_LABEL => AsmInstKind::Label(Label::from_inst_payload(payload)),
+            Self::TAG_PUSH_LABEL_FIXED => {
+                let label = Label::from_inst_payload(payload & Self::FIXED_LABEL_MASK);
+                let width = ((payload >> Self::FIXED_WIDTH_SHIFT) + 1) as u8;
+                AsmInstKind::PushLabelFixed(label, width)
+            }
             _ => unreachable!("invalid assembler instruction tag"),
         }
     }
@@ -125,6 +141,7 @@ pub(in crate::backend::evm) enum AsmInstKind {
     PushInline(u32),
     Push(PushValueId),
     PushLabel(Label),
+    PushLabelFixed(Label, u8),
     PushDeferred(DeferredConst),
     PushImmutable(u32),
     Label(Label),
diff --git a/crates/codegen/src/backend/evm/ir/assembly/lower.rs b/crates/codegen/src/backend/evm/ir/assembly/lower.rs
index c84e3e581..c1005ddcc 100644
--- a/crates/codegen/src/backend/evm/ir/assembly/lower.rs
+++ b/crates/codegen/src/backend/evm/ir/assembly/lower.rs
@@ -6,14 +6,27 @@ use crate::backend::evm::{
     ir::{self, BlockId},
     op,
 };
-use solar_data_structures::bit_set::DenseBitSet;
+use alloy_primitives::U256;
+use solar_config::EvmVersion;
+use solar_data_structures::{
+    bit_set::DenseBitSet,
+    index::{IndexVec, index_vec},
+};
+
+struct IndexedJumpTable {
+    entries: Box<[BlockId]>,
+    targets: Box<[BlockId]>,
+}
 
 /// Lowers finalized EVM IR into the linear label-bearing assembly stream.
 pub(in crate::backend::evm) fn lower_evm_ir(
-    module: &ir::Module,
+    module: &mut ir::Module,
     labels: &mut Vec<Option<Label>>,
     assembler: &mut Assembler<'_>,
+    evm_version: EvmVersion,
 ) -> Program {
+    let tables = materialize_indexed_jump_tables(module);
+    let table_entry_widths = indexed_jump_target_widths(module, evm_version, &tables);
     allocate_referenced_labels(module, labels, assembler);
 
     let mut program = Program::default();
@@ -28,12 +41,186 @@ pub(in crate::backend::evm) fn lower_evm_ir(
         }
 
         if let Some(terminator) = &block.terminator {
-            lower_terminator(&mut program, block_id, &terminator.kind, module, labels, assembler);
+            let table_target_width = match &terminator.kind {
+                ir::TerminatorKind::IndexedJump(targets) => {
+                    table_entry_widths[*targets.first().expect("validated indexed jump table")]
+                }
+                _ => table_entry_widths[block_id],
+            };
+            lower_terminator(
+                &mut program,
+                block_id,
+                &terminator.kind,
+                module,
+                labels,
+                assembler,
+                table_target_width,
+            );
         }
     }
     program
 }
 
+fn materialize_indexed_jump_tables(module: &mut ir::Module) -> Vec<IndexedJumpTable> {
+    let tables = module
+        .blocks
+        .iter_enumerated()
+        .filter_map(|(block, data)| {
+            let targets = match &data.terminator.as_ref()?.kind {
+                ir::TerminatorKind::IndexedJump(targets) => targets.clone(),
+                _ => return None,
+            };
+            Some((block, targets))
+        })
+        .collect::<Vec<_>>();
+    let mut next_label = module
+        .blocks
+        .iter()
+        .map(|block| block.label)
+        .max()
+        .map_or(0, |label| label.checked_add(1).expect("EVM IR block label overflow"));
+    let mut result = Vec::new();
+
+    for (source, targets) in tables {
+        let mut entries = Vec::with_capacity(targets.len());
+        for &target in &targets {
+            let mut block = ir::Block::new(next_label);
+            next_label = next_label.checked_add(1).expect("EVM IR block label overflow");
+            block.terminator = Some(ir::Terminator::new(ir::TerminatorKind::Jump(target)));
+            let entry = module.add_block(block);
+            entries.push(entry);
+        }
+        module.blocks[source]
+            .terminator
+            .as_mut()
+            .expect("indexed jump source must have a terminator")
+            .kind = ir::TerminatorKind::IndexedJump(entries.clone().into_boxed_slice());
+        result.push(IndexedJumpTable { entries: entries.into_boxed_slice(), targets });
+    }
+
+    result
+}
+
+fn indexed_jump_target_widths(
+    module: &ir::Module,
+    evm_version: EvmVersion,
+    tables: &[IndexedJumpTable],
+) -> IndexVec<BlockId, Option<u8>> {
+    let mut widths = index_vec![None; module.blocks.len()];
+    if tables.is_empty() {
+        return widths;
+    }
+
+    let global_width = (1..=32)
+        .find(|&width| push_width_fits(estimated_module_size(module, evm_version, width), width))
+        .expect("a bytecode offset must fit one EVM word");
+    let offsets = estimated_block_offsets(module, evm_version, global_width);
+    for table in tables {
+        let max_offset = table.targets.iter().map(|&target| offsets[target]).max().unwrap_or(0);
+        let width = (1..=global_width)
+            .find(|&width| push_width_fits(max_offset.saturating_add(1), width))
+            .unwrap_or(global_width);
+        for &entry in &table.entries {
+            widths[entry] = Some(width);
+        }
+    }
+    widths
+}
+
+fn push_width_fits(size: usize, width: u8) -> bool {
+    let bits = u32::from(width) * 8;
+    bits >= usize::BITS || size <= 1usize << bits
+}
+
+fn estimated_block_offsets(
+    module: &ir::Module,
+    evm_version: EvmVersion,
+    block_target_width: u8,
+) -> IndexVec<BlockId, usize> {
+    let mut offsets = IndexVec::with_capacity(module.blocks.len());
+    let mut offset = 0usize;
+    for (block_id, block) in module.blocks.iter_enumerated() {
+        offsets.push(offset);
+        offset = offset.saturating_add(estimated_block_size(
+            module,
+            block_id,
+            block,
+            evm_version,
+            block_target_width,
+        ));
+    }
+    offsets
+}
+
+fn estimated_module_size(
+    module: &ir::Module,
+    evm_version: EvmVersion,
+    block_target_width: u8,
+) -> usize {
+    module
+        .blocks
+        .iter_enumerated()
+        .map(|(block_id, block)| {
+            estimated_block_size(module, block_id, block, evm_version, block_target_width)
+        })
+        .fold(0, usize::saturating_add)
+}
+
+fn estimated_block_size(
+    module: &ir::Module,
+    block_id: BlockId,
+    block: &ir::Block,
+    evm_version: EvmVersion,
+    block_target_width: u8,
+) -> usize {
+    let mut size = 1usize;
+    for inst in &block.instructions {
+        let inst_size = if inst.deferred_push().is_some() || inst.immutable_push().is_some() {
+            33
+        } else if inst.is_encoded_push() {
+            match &inst.value {
+                Some(ir::PushValue::Immediate(value)) => push_len(*value, evm_version),
+                Some(ir::PushValue::Block(_)) => usize::from(block_target_width) + 1,
+                None => unreachable!("push must carry a value"),
+            }
+        } else {
+            1
+        };
+        size = size.saturating_add(inst_size);
+    }
+    if let Some(term) = &block.terminator {
+        size = size.saturating_add(estimated_terminator_size(
+            &term.kind,
+            next_block(module, block_id),
+            block_target_width,
+        ));
+    }
+    size
+}
+
+fn estimated_terminator_size(kind: &ir::TerminatorKind, next: Option<BlockId>, width: u8) -> usize {
+    let push = usize::from(width) + 1;
+    match kind {
+        ir::TerminatorKind::Jump(target) => usize::from(Some(*target) != next) * (push + 1),
+        ir::TerminatorKind::JumpI { then_block, else_block } => {
+            if Some(*else_block) == next {
+                push + 1
+            } else if Some(*then_block) == next {
+                push + 2
+            } else {
+                push * 2 + 2
+            }
+        }
+        ir::TerminatorKind::IndexedJump(_) => push + 5,
+        ir::TerminatorKind::Op(op::STOP) => usize::from(next.is_some()),
+        ir::TerminatorKind::Op(_) => 1,
+    }
+}
+
+fn push_len(value: U256, evm_version: EvmVersion) -> usize {
+    if value.is_zero() && evm_version.has_push0() { 1 } else { value.byte_len().max(1) + 1 }
+}
+
 fn allocate_referenced_labels(
     module: &ir::Module,
     labels: &mut Vec<Option<Label>>,
@@ -96,9 +283,16 @@ fn lower_terminator(
     module: &ir::Module,
     labels: &mut Vec<Option<Label>>,
     assembler: &mut Assembler<'_>,
+    table_target_width: Option<u8>,
 ) {
     match kind {
         ir::TerminatorKind::Jump(target) => {
+            if let Some(table_target_width) = table_target_width {
+                let label = label_for_block(module, *target, labels, assembler);
+                program.push(AsmInst::push_label_fixed(label, table_target_width));
+                program.push_op(op::JUMP);
+                return;
+            }
             if next_block(module, block_id) == Some(*target) {
                 return;
             }
@@ -126,6 +320,23 @@ fn lower_terminator(
                 program.push_op(op::JUMP);
             }
         }
+        ir::TerminatorKind::IndexedJump(targets) => {
+            let (&table, rest) = targets.split_first().expect("validated indexed jump table");
+            debug_assert!(
+                rest.iter()
+                    .enumerate()
+                    .all(|(index, target)| { target.index() == table.index() + index + 1 })
+            );
+            let table_target_width = table_target_width.expect("indexed jump table width");
+            let stub_len = u32::from(table_target_width) + 3;
+            program.push(
+                AsmInst::push_inline(stub_len).expect("indexed jump stub length must fit inline"),
+            );
+            program.push_op(op::MUL);
+            program.push_label(label_for_block(module, table, labels, assembler));
+            program.push_op(op::ADD);
+            program.push_op(op::JUMP);
+        }
         ir::TerminatorKind::Op(opcode) => {
             if *opcode != op::STOP || next_block(module, block_id).is_some() {
                 program.push_op(*opcode);
@@ -162,6 +373,7 @@ mod tests {
     use alloy_primitives::U256;
     use solar_interface::Session;
     use solar_sema::Compiler;
+
     #[test]
     fn branch_inverts_when_then_target_falls_through() {
         let mut module = ir::Module::new("module");
@@ -178,7 +390,7 @@ mod tests {
         compiler.enter(|c| {
             let mut labels = vec![None; 3];
             let mut assembler = Assembler::new(c.gcx());
-            let program = lower_evm_ir(&module, &mut labels, &mut assembler);
+            let program = lower_evm_ir(&mut module, &mut labels, &mut assembler, EvmVersion::Osaka);
             let kinds: Vec<_> = program.instructions.iter().map(|inst| inst.kind()).collect();
 
             assert!(matches!(
@@ -194,4 +406,87 @@ mod tests {
             ));
         });
     }
+
+    #[test]
+    fn indexed_jump_entries_are_reachable_blocks() {
+        let mut module = ir::Module::new("module");
+        let entry = module.add_block(Block::new(0));
+        let left = module.add_block(Block::new(1));
+        let right = module.add_block(Block::new(2));
+        module.blocks[entry].instructions.push(Instruction::push_value(U256::ONE));
+        module.blocks[entry].terminator = Some(Terminator::new(TerminatorKind::IndexedJump(
+            vec![left, right].into_boxed_slice(),
+        )));
+        module.blocks[left].terminator = Some(Terminator::new(TerminatorKind::Op(op::STOP)));
+        module.blocks[right].terminator = Some(Terminator::new(TerminatorKind::Op(op::INVALID)));
+
+        let compiler = Compiler::new(Session::builder().opts(Default::default()).build());
+        compiler.enter(|c| {
+            let mut labels = vec![None; 3];
+            let mut assembler = Assembler::new(c.gcx());
+            let program = lower_evm_ir(&mut module, &mut labels, &mut assembler, EvmVersion::Osaka);
+
+            let TerminatorKind::IndexedJump(entries) =
+                &module.blocks[entry].terminator.as_ref().unwrap().kind
+            else {
+                panic!("expected indexed jump")
+            };
+            assert_eq!(entries.len(), 2);
+            assert!(matches!(
+                module.blocks[entries[0]].terminator.as_ref().map(|term| &term.kind),
+                Some(TerminatorKind::Jump(target)) if *target == left
+            ));
+            assert!(matches!(
+                module.blocks[entries[1]].terminator.as_ref().map(|term| &term.kind),
+                Some(TerminatorKind::Jump(target)) if *target == right
+            ));
+            assert_eq!(
+                program
+                    .instructions
+                    .iter()
+                    .filter_map(|inst| match inst.kind() {
+                        AsmInstKind::PushLabelFixed(_, width) => Some(width),
+                        _ => None,
+                    })
+                    .collect::<Vec<_>>(),
+                vec![1, 1]
+            );
+        });
+    }
+
+    #[test]
+    fn widens_table_targets_when_program_exceeds_push1() {
+        let mut module = ir::Module::new("module");
+        let entry = module.add_block(Block::new(0));
+        let target = module.add_block(Block::new(1));
+        for id in 0..8 {
+            module.blocks[entry].instructions.push(Instruction::push_immutable(id));
+        }
+        module.blocks[entry].terminator =
+            Some(Terminator::new(TerminatorKind::IndexedJump(vec![target].into_boxed_slice())));
+        module.blocks[target].terminator = Some(Terminator::new(TerminatorKind::Op(op::STOP)));
+
+        let tables = materialize_indexed_jump_tables(&mut module);
+        let widths = indexed_jump_target_widths(&module, EvmVersion::Osaka, &tables);
+        assert_eq!(widths[tables[0].entries[0]], Some(2));
+    }
+
+    #[test]
+    fn packs_early_table_targets_in_large_modules() {
+        let mut module = ir::Module::new("module");
+        let entry = module.add_block(Block::new(0));
+        let target = module.add_block(Block::new(1));
+        let padding = module.add_block(Block::new(2));
+        module.blocks[entry].terminator =
+            Some(Terminator::new(TerminatorKind::IndexedJump(vec![target].into_boxed_slice())));
+        module.blocks[target].terminator = Some(Terminator::new(TerminatorKind::Op(op::STOP)));
+        for id in 0..8 {
+            module.blocks[padding].instructions.push(Instruction::push_immutable(id));
+        }
+        module.blocks[padding].terminator = Some(Terminator::new(TerminatorKind::Op(op::STOP)));
+
+        let tables = materialize_indexed_jump_tables(&mut module);
+        let widths = indexed_jump_target_widths(&module, EvmVersion::Osaka, &tables);
+        assert_eq!(widths[tables[0].entries[0]], Some(1));
+    }
 }
diff --git a/crates/codegen/src/backend/evm/ir/display.rs b/crates/codegen/src/backend/evm/ir/display.rs
index a01874180..956009268 100644
--- a/crates/codegen/src/backend/evm/ir/display.rs
+++ b/crates/codegen/src/backend/evm/ir/display.rs
@@ -58,6 +58,18 @@ fn display_terminator<'a>(module: &'a Module, term: &'a Terminator) -> impl fmt:
                     display_block_id(module, *else_block)
                 )?;
             }
+            TerminatorKind::IndexedJump(targets) => {
+                write!(f, "indexed_jump ")?;
+                write!(
+                    f,
+                    "{}",
+                    targets.iter().format_with(", ", |f, target| write!(
+                        f,
+                        "{}",
+                        display_block_id(module, *target)
+                    ))
+                )?;
+            }
             TerminatorKind::Op(opcode) => {
                 if let Some(mnemonic) = op::mnemonic(*opcode) {
                     write!(f, "{mnemonic}")?;
diff --git a/crates/codegen/src/backend/evm/ir/mod.rs b/crates/codegen/src/backend/evm/ir/mod.rs
index 2f1d160b8..09773f820 100644
--- a/crates/codegen/src/backend/evm/ir/mod.rs
+++ b/crates/codegen/src/backend/evm/ir/mod.rs
@@ -306,6 +306,8 @@ pub(crate) enum TerminatorKind {
         /// Target when condition is zero.
         else_block: BlockId,
     },
+    /// Jump through a dense zero-based table using an index from the stack.
+    IndexedJump(Box<[BlockId]>),
     /// Terminal EVM opcode.
     Op(u8),
 }
@@ -319,6 +321,7 @@ impl TerminatorKind {
                 visit(*then_block);
                 visit(*else_block);
             }
+            Self::IndexedJump(targets) => targets.iter().copied().for_each(visit),
             Self::Op(_) => {}
         }
     }
@@ -345,6 +348,7 @@ impl TerminatorKind {
                     visit(*else_block);
                 }
             }
+            Self::IndexedJump(targets) => targets.iter().copied().for_each(visit),
             Self::Op(_) => {}
         }
     }
@@ -357,6 +361,7 @@ impl TerminatorKind {
                 visit(then_block);
                 visit(else_block);
             }
+            Self::IndexedJump(targets) => targets.iter_mut().for_each(visit),
             Self::Op(_) => {}
         }
     }
@@ -413,6 +418,7 @@ pub(super) fn default_instruction_stack_effect(inst: &Instruction) -> Option<Sta
 fn default_terminator_stack_effect(kind: &TerminatorKind) -> Option<StackEffect> {
     match kind {
         TerminatorKind::JumpI { .. } => Some(StackEffect::new(1, 0)),
+        TerminatorKind::IndexedJump(_) => Some(StackEffect::new(1, 0)),
         TerminatorKind::Jump(_) => Some(StackEffect::new(0, 0)),
         TerminatorKind::Op(opcode) => {
             op::stack_io(*opcode).map(|(inputs, outputs)| StackEffect::new(inputs, outputs))
diff --git a/crates/codegen/src/backend/evm/ir/parse.rs b/crates/codegen/src/backend/evm/ir/parse.rs
index 5ab9deaea..794d3185f 100644
--- a/crates/codegen/src/backend/evm/ir/parse.rs
+++ b/crates/codegen/src/backend/evm/ir/parse.rs
@@ -210,6 +210,13 @@ impl<'sess, 'ast> Parser<'sess, 'ast> {
                 let else_block = self.parse_block_ref(module)?;
                 TerminatorKind::JumpI { then_block, else_block }
             }
+            sym::indexed_jump => {
+                let mut targets = vec![self.parse_block_ref(module)?];
+                while self.parser.eat(TokenKind::Comma) {
+                    targets.push(self.parse_block_ref(module)?);
+                }
+                TerminatorKind::IndexedJump(targets.into_boxed_slice())
+            }
             kw::Return => TerminatorKind::Op(op::RETURN),
             kw::Revert => TerminatorKind::Op(op::REVERT),
             kw::Stop => TerminatorKind::Op(op::STOP),
diff --git a/crates/codegen/src/backend/evm/ir/passes/block_layout.rs b/crates/codegen/src/backend/evm/ir/passes/block_layout.rs
index bb14dfc44..61eaffcb7 100644
--- a/crates/codegen/src/backend/evm/ir/passes/block_layout.rs
+++ b/crates/codegen/src/backend/evm/ir/passes/block_layout.rs
@@ -238,6 +238,7 @@ fn estimated_terminator_size(kind: &TerminatorKind, next: Option<BlockId>) -> us
                 8
             }
         }
+        TerminatorKind::IndexedJump(targets) => 8 + targets.len() * 5,
         TerminatorKind::Op(_) => 1,
     }
 }
diff --git a/crates/codegen/src/backend/evm/ir/passes/utils.rs b/crates/codegen/src/backend/evm/ir/passes/utils.rs
index 93b8ab385..87ba7ba6f 100644
--- a/crates/codegen/src/backend/evm/ir/passes/utils.rs
+++ b/crates/codegen/src/backend/evm/ir/passes/utils.rs
@@ -11,7 +11,8 @@ use crate::backend::evm::{
 use solar_data_structures::index::{IndexVec, index_vec};
 
 pub(super) fn is_evm_terminal(kind: &TerminatorKind) -> bool {
-    matches!(kind, TerminatorKind::Op(opcode) if op::is_terminal(*opcode))
+    matches!(kind, TerminatorKind::IndexedJump(_))
+        || matches!(kind, TerminatorKind::Op(opcode) if op::is_terminal(*opcode))
 }
 
 pub(in crate::backend::evm::ir) fn remap_block_order(module: &mut Module, order: &[BlockId]) {
diff --git a/crates/codegen/src/backend/evm/ir/verify.rs b/crates/codegen/src/backend/evm/ir/verify.rs
index e0c4c92e4..dceb5e7d6 100644
--- a/crates/codegen/src/backend/evm/ir/verify.rs
+++ b/crates/codegen/src/backend/evm/ir/verify.rs
@@ -157,6 +157,9 @@ impl<'a> Verifier<'a> {
     }
 
     fn verify_terminator_shape(&self, block_id: BlockId, term: &Terminator) {
+        if matches!(&term.kind, TerminatorKind::IndexedJump(targets) if targets.is_empty()) {
+            self.error_in_block(block_id, "`indexed_jump` must have at least one target");
+        }
         if let TerminatorKind::Op(opcode) = &term.kind
             && !op::is_terminal(*opcode)
         {
@@ -364,6 +367,7 @@ fn terminator_name(kind: &TerminatorKind) -> &'static str {
     match kind {
         TerminatorKind::Jump(_) => "jump",
         TerminatorKind::JumpI { .. } => "jumpi",
+        TerminatorKind::IndexedJump(_) => "indexed_jump",
         TerminatorKind::Op(opcode) => op::mnemonic(*opcode).unwrap_or("terminal"),
     }
 }
diff --git a/crates/codegen/src/backend/evm/mod.rs b/crates/codegen/src/backend/evm/mod.rs
index edee1dfc5..241ad8577 100644
--- a/crates/codegen/src/backend/evm/mod.rs
+++ b/crates/codegen/src/backend/evm/mod.rs
@@ -20,5 +20,7 @@ pub(crate) mod assembler;
 
 pub(crate) mod stack;
 
+mod switch;
+
 #[cfg(test)]
 pub(crate) mod test_utils;
diff --git a/crates/codegen/src/backend/evm/switch.rs b/crates/codegen/src/backend/evm/switch.rs
new file mode 100644
index 000000000..e32fd760e
--- /dev/null
+++ b/crates/codegen/src/backend/evm/switch.rs
@@ -0,0 +1,433 @@
+//! Target-aware switch lowering selection.
+
+use alloy_primitives::U256;
+use solar_config::{EvmVersion, OptimizationMode};
+
+// Ordinary label pushes relax after layout. Use their minimum possible size so
+// fixed-width tables are selected for size only when they beat the best case.
+const LABEL_PUSH_LEN: usize = 2;
+const JUMPDEST_LEN: usize = 1;
+const DEFAULT_JUMP_LEN: usize = LABEL_PUSH_LEN + 1;
+
+const VERY_LOW_GAS: usize = 3;
+const JUMP_GAS: usize = 8;
+const JUMPI_GAS: usize = 10;
+const DEFAULT_JUMP_GAS: usize = VERY_LOW_GAS + JUMP_GAS;
+const POP_GAS: usize = 2;
+const MOD_GAS: usize = 5;
+const MUL_GAS: usize = 5;
+const JUMPDEST_GAS: usize = 1;
+
+const INDEXED_JUMP_BASE_LEN: usize = 7;
+const MIN_BUCKET_CASES: usize = 8;
+// Bound table footprint and the number of bucket blocks processed by EVM IR passes.
+const MAX_BUCKET_CASES: usize = 64;
+const MAX_DENSE_RANGE: usize = 4096;
+const MAX_BUCKET_CANDIDATES: usize = 33;
+
+/// Selected control-flow shape for a switch.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum SwitchPlan {
+    /// Test every case in source order.
+    Linear,
+    /// Recursively split sorted cases, using linear leaves of at most this size.
+    Binary { leaf_size: usize },
+    /// Dispatch by `value % bucket_count`, then linearly scan one bucket.
+    Buckets { bucket_count: usize },
+    /// Bounds-check `value - low` and dispatch through a dense target table.
+    Dense { low: U256, range: usize },
+}
+
+/// Selects the cheapest supported switch shape for the optimization objective.
+pub(super) fn select_switch_plan(
+    values: &[U256],
+    optimization: OptimizationMode,
+    evm_version: EvmVersion,
+    needs_empty_cleanup: bool,
+    table_target_width: usize,
+) -> SwitchPlan {
+    debug_assert!(values.windows(2).all(|values| values[0] < values[1]));
+    if values.len() <= 1 || optimization == OptimizationMode::None {
+        return SwitchPlan::Linear;
+    }
+
+    let mut best = (lowering_cost(values, values.len(), evm_version), SwitchPlan::Linear);
+    if optimization == OptimizationMode::Gas {
+        for leaf_size in binary_leaf_sizes(values.len()) {
+            let cost = lowering_cost(values, leaf_size, evm_version);
+            if cost.gas_key() < best.0.gas_key() {
+                best = (cost, SwitchPlan::Binary { leaf_size });
+            }
+        }
+        if (MIN_BUCKET_CASES..=MAX_BUCKET_CASES).contains(&values.len()) {
+            for bucket_count in bucket_count_candidates(values.len()) {
+                let cost = bucket_lowering_cost(
+                    values,
+                    bucket_count,
+                    evm_version,
+                    needs_empty_cleanup,
+                    table_target_width,
+                );
+                if cost.gas_key() < best.0.gas_key() {
+                    best = (cost, SwitchPlan::Buckets { bucket_count });
+                }
+            }
+        }
+    }
+    if let Some((low, range, cost)) = dense_lowering_cost(values, evm_version, table_target_width) {
+        let better = match optimization {
+            OptimizationMode::Gas => cost.gas_key() < best.0.gas_key(),
+            OptimizationMode::Size => cost.size_key() < best.0.size_key(),
+            _ => false,
+        };
+        if better {
+            best = (cost, SwitchPlan::Dense { low, range });
+        }
+    }
+    best.1
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+struct LoweringCost {
+    code_size: usize,
+    hit_gas_sum: usize,
+    miss_gas: usize,
+}
+
+impl LoweringCost {
+    fn gas_key(self) -> (usize, usize, usize) {
+        (self.hit_gas_sum, self.miss_gas, self.code_size)
+    }
+
+    fn size_key(self) -> (usize, usize, usize) {
+        (self.code_size, self.hit_gas_sum, self.miss_gas)
+    }
+}
+
+fn lowering_cost(values: &[U256], leaf_size: usize, evm_version: EvmVersion) -> LoweringCost {
+    if values.len() <= leaf_size {
+        let mut cost = LoweringCost { code_size: DEFAULT_JUMP_LEN, ..Default::default() };
+        let mut path_gas = 0;
+        for &value in values {
+            let test = equality_test_cost(value, evm_version);
+            cost.code_size += test.code_size;
+            path_gas += test.gas;
+            cost.hit_gas_sum += path_gas;
+        }
+        cost.miss_gas = path_gas + DEFAULT_JUMP_GAS;
+        return cost;
+    }
+
+    let mid = values.len() / 2;
+    let split = ordered_test_cost(values[mid], evm_version);
+    let left = lowering_cost(&values[..mid], leaf_size, evm_version);
+    let right = lowering_cost(&values[mid..], leaf_size, evm_version);
+    LoweringCost {
+        code_size: split.code_size + JUMPDEST_LEN + left.code_size + right.code_size,
+        hit_gas_sum: split.gas * values.len()
+            + left.hit_gas_sum
+            + mid * JUMPDEST_GAS
+            + right.hit_gas_sum,
+        miss_gas: split.gas + (left.miss_gas + JUMPDEST_GAS).max(right.miss_gas),
+    }
+}
+
+fn binary_leaf_sizes(len: usize) -> Vec<usize> {
+    let mut pending = vec![len];
+    let mut sizes = Vec::new();
+    while let Some(len) = pending.pop() {
+        if len <= 1 {
+            continue;
+        }
+        let mid = len / 2;
+        for child in [mid, len - mid] {
+            if child > 0 && child < len && !sizes.contains(&child) {
+                sizes.push(child);
+                pending.push(child);
+            }
+        }
+    }
+    sizes.sort_unstable();
+    sizes
+}
+
+fn bucket_count_candidates(len: usize) -> Vec<usize> {
+    let first = (len.saturating_mul(3) / 4).max(2);
+    let last = len.saturating_mul(5) / 4;
+    let count = last - first + 1;
+    if count <= MAX_BUCKET_CANDIDATES {
+        return (first..=last).collect();
+    }
+
+    let span = last - first;
+    let denominator = MAX_BUCKET_CANDIDATES - 1;
+    let mut candidates = (0..MAX_BUCKET_CANDIDATES)
+        .map(|index| first + span.saturating_mul(index) / denominator)
+        .collect::<Vec<_>>();
+    candidates.push(len);
+    candidates.sort_unstable();
+    candidates.dedup();
+    candidates
+}
+
+fn bucket_lowering_cost(
+    values: &[U256],
+    bucket_count: usize,
+    evm_version: EvmVersion,
+    needs_empty_cleanup: bool,
+    table_target_width: usize,
+) -> LoweringCost {
+    let hash_len = 1 + push_len(U256::from(bucket_count), evm_version) + 1 + 1;
+    let hash_gas = VERY_LOW_GAS * 3 + MOD_GAS;
+    let indexed_jump_gas = VERY_LOW_GAS
+        + MUL_GAS
+        + VERY_LOW_GAS
+        + VERY_LOW_GAS
+        + JUMP_GAS
+        + JUMPDEST_GAS
+        + VERY_LOW_GAS
+        + JUMP_GAS
+        + JUMPDEST_GAS;
+    let dispatch_gas = hash_gas + indexed_jump_gas;
+    let mut cost = LoweringCost {
+        code_size: hash_len
+            + INDEXED_JUMP_BASE_LEN
+            + bucket_count * indexed_jump_stub_len(table_target_width),
+        hit_gas_sum: dispatch_gas * values.len(),
+        miss_gas: dispatch_gas,
+    };
+
+    let mut bucket_path_gas = vec![0; bucket_count];
+    for &value in values {
+        let index = bucket_index(value, bucket_count);
+        let test = equality_test_cost(value, evm_version);
+        if bucket_path_gas[index] == 0 {
+            cost.code_size += JUMPDEST_LEN + DEFAULT_JUMP_LEN;
+        }
+        cost.code_size += test.code_size;
+        bucket_path_gas[index] += test.gas;
+        cost.hit_gas_sum += bucket_path_gas[index];
+        cost.miss_gas = cost.miss_gas.max(dispatch_gas + bucket_path_gas[index] + DEFAULT_JUMP_GAS);
+    }
+    if needs_empty_cleanup && bucket_path_gas.contains(&0) {
+        // One shared JUMPDEST, POP, and default jump for ordinary MIR switches.
+        cost.code_size += JUMPDEST_LEN + 1 + DEFAULT_JUMP_LEN;
+        cost.miss_gas = cost.miss_gas.max(dispatch_gas + POP_GAS + DEFAULT_JUMP_GAS);
+    }
+    cost
+}
+
+fn dense_lowering_cost(
+    values: &[U256],
+    evm_version: EvmVersion,
+    table_target_width: usize,
+) -> Option<(U256, usize, LoweringCost)> {
+    let low = *values.first()?;
+    let high = *values.last()?;
+    let range = usize::try_from(high - low).ok()?.checked_add(1)?;
+    if range > MAX_DENSE_RANGE {
+        return None;
+    }
+
+    let normalize_len = usize::from(!low.is_zero()) * (push_len(low, evm_version) + 2);
+    let normalize_gas = usize::from(!low.is_zero()) * VERY_LOW_GAS * 3;
+    let bounds_len = 1 + push_len(U256::from(range), evm_version) + 1 + 1 + LABEL_PUSH_LEN + 1;
+    let bounds_gas = VERY_LOW_GAS * 5 + JUMPI_GAS;
+    let indexed_jump_gas = VERY_LOW_GAS
+        + MUL_GAS
+        + VERY_LOW_GAS
+        + VERY_LOW_GAS
+        + JUMP_GAS
+        + JUMPDEST_GAS
+        + VERY_LOW_GAS
+        + JUMP_GAS;
+    let hit_gas = normalize_gas + bounds_gas + JUMPDEST_GAS + indexed_jump_gas;
+    let miss_gas = normalize_gas + bounds_gas + 2 + DEFAULT_JUMP_GAS;
+    Some((
+        low,
+        range,
+        LoweringCost {
+            code_size: normalize_len
+                + bounds_len
+                + 1
+                + DEFAULT_JUMP_LEN
+                + JUMPDEST_LEN
+                + INDEXED_JUMP_BASE_LEN
+                + range * indexed_jump_stub_len(table_target_width),
+            hit_gas_sum: hit_gas * values.len(),
+            miss_gas,
+        },
+    ))
+}
+
+const fn indexed_jump_stub_len(target_width: usize) -> usize {
+    // JUMPDEST, PUSH<n> target, JUMP.
+    target_width + 3
+}
+
+pub(super) fn bucket_index(value: U256, bucket_count: usize) -> usize {
+    let limbs = value.as_limbs();
+    if limbs[1..].iter().all(|&limb| limb == 0) {
+        return (limbs[0] % bucket_count as u64) as usize;
+    }
+
+    let modulus = bucket_count as u128;
+    limbs.iter().rev().fold(0, |remainder, &limb| ((remainder << 64) | limb as u128) % modulus)
+        as usize
+}
+
+#[derive(Clone, Copy)]
+struct TestCost {
+    code_size: usize,
+    gas: usize,
+}
+
+fn equality_test_cost(value: U256, evm_version: EvmVersion) -> TestCost {
+    if value.is_zero() {
+        // DUP1, ISZERO, PUSH<label>, JUMPI.
+        TestCost {
+            code_size: 1 + 1 + LABEL_PUSH_LEN + 1,
+            gas: VERY_LOW_GAS + VERY_LOW_GAS + VERY_LOW_GAS + JUMPI_GAS,
+        }
+    } else {
+        ordered_test_cost(value, evm_version)
+    }
+}
+
+fn ordered_test_cost(value: U256, evm_version: EvmVersion) -> TestCost {
+    // DUP1, PUSH<value>, EQ/GT, PUSH<label>, JUMPI.
+    TestCost {
+        code_size: 1 + push_len(value, evm_version) + 1 + LABEL_PUSH_LEN + 1,
+        gas: VERY_LOW_GAS * 4 + JUMPI_GAS,
+    }
+}
+
+fn push_len(value: U256, evm_version: EvmVersion) -> usize {
+    if value.is_zero() && evm_version.has_push0() { 1 } else { 1 + value.byte_len().max(1) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn values(n: usize) -> Vec<U256> {
+        (0..n).map(U256::from).collect()
+    }
+
+    #[test]
+    fn leaves_small_switches_linear() {
+        assert_eq!(
+            select_switch_plan(&values(4), OptimizationMode::Gas, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Linear
+        );
+    }
+
+    #[test]
+    fn selects_profitable_binary_leaf_size() {
+        let values = (0..5).map(|value| U256::from(value * 7919)).collect::<Vec<_>>();
+        assert_eq!(
+            select_switch_plan(&values, OptimizationMode::Gas, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Binary { leaf_size: 3 }
+        );
+    }
+
+    #[test]
+    fn accounts_for_taken_binary_split_labels() {
+        let values = (0..7).map(|value| U256::from(1 + value * 7919)).collect::<Vec<_>>();
+        assert_eq!(
+            select_switch_plan(&values, OptimizationMode::Gas, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Binary { leaf_size: 4 }
+        );
+    }
+
+    #[test]
+    fn bounds_bucket_search_for_large_switches() {
+        let candidates = bucket_count_candidates(10_000);
+        assert!(candidates.len() <= MAX_BUCKET_CANDIDATES + 1);
+        assert!(candidates.contains(&10_000));
+        assert!(bucket_count_candidates(97).contains(&97));
+    }
+
+    #[test]
+    fn computes_bucket_indices_without_wide_division() {
+        for value in [U256::ZERO, U256::from(u64::MAX), U256::MAX] {
+            for bucket_count in [1, 7, 32, 127, usize::MAX] {
+                assert_eq!(
+                    bucket_index(value, bucket_count),
+                    usize::try_from(value % U256::from(bucket_count)).unwrap()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn charges_empty_bucket_cleanup_only_when_needed() {
+        let values = [U256::ZERO, U256::from(2)];
+        let with_cleanup = bucket_lowering_cost(&values, 4, EvmVersion::Cancun, true, 2);
+        let without_cleanup = bucket_lowering_cost(&values, 4, EvmVersion::Cancun, false, 2);
+        assert_eq!(
+            with_cleanup.code_size,
+            without_cleanup.code_size + JUMPDEST_LEN + 1 + DEFAULT_JUMP_LEN
+        );
+        assert_eq!(with_cleanup.hit_gas_sum, without_cleanup.hit_gas_sum);
+    }
+
+    #[test]
+    fn accounts_for_packed_table_target_widths() {
+        let values = (0..32).map(|value| U256::from(value * 7919)).collect::<Vec<_>>();
+        let packed = bucket_lowering_cost(&values, 32, EvmVersion::Cancun, true, 2);
+        let wide = bucket_lowering_cost(&values, 32, EvmVersion::Cancun, true, 3);
+
+        assert_eq!(wide.code_size, packed.code_size + 32);
+        assert_eq!(wide.hit_gas_sum, packed.hit_gas_sum);
+        assert_eq!(wide.miss_gas, packed.miss_gas);
+    }
+
+    #[test]
+    fn preserves_linear_shape_outside_gas_mode() {
+        let sparse = (0..64).map(|value| U256::from(value * 7919)).collect::<Vec<_>>();
+        assert_eq!(
+            select_switch_plan(&sparse, OptimizationMode::None, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Linear
+        );
+        assert_eq!(
+            select_switch_plan(&sparse, OptimizationMode::Size, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Linear
+        );
+    }
+
+    #[test]
+    fn selects_buckets_for_large_sparse_switches() {
+        let values = (0..32).map(|value| U256::from(value * 7919)).collect::<Vec<_>>();
+        assert!(matches!(
+            select_switch_plan(&values, OptimizationMode::Gas, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Buckets { .. }
+        ));
+    }
+
+    #[test]
+    fn bounds_bucket_table_fanout() {
+        let values = (0..100).map(|value| U256::from(value * 7919)).collect::<Vec<_>>();
+        assert!(matches!(
+            select_switch_plan(&values, OptimizationMode::Gas, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Binary { .. }
+        ));
+    }
+
+    #[test]
+    fn selects_dense_table_for_compact_ranges() {
+        let values = values(24);
+        assert_eq!(
+            select_switch_plan(&values, OptimizationMode::Size, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Dense { low: U256::ZERO, range: 24 }
+        );
+    }
+
+    #[test]
+    fn rejects_larger_dense_table_for_small_compact_ranges() {
+        assert_eq!(
+            select_switch_plan(&values(8), OptimizationMode::Size, EvmVersion::Cancun, true, 2),
+            SwitchPlan::Linear
+        );
+    }
+}
diff --git a/crates/interface/src/symbol.rs b/crates/interface/src/symbol.rs
index 354c9cf46..84ea0c75c 100644
--- a/crates/interface/src/symbol.rs
+++ b/crates/interface/src/symbol.rs
@@ -1017,6 +1017,7 @@ symbols! {
         global,
         heap,
         hir,
+        indexed_jump,
         infallible,
         interfaceId,
         internal_call,
diff --git a/tests/foundry/correctness/test/SwitchTables.t.sol b/tests/foundry/correctness/test/SwitchTables.t.sol
new file mode 100644
index 000000000..55c1d50c1
--- /dev/null
+++ b/tests/foundry/correctness/test/SwitchTables.t.sol
@@ -0,0 +1,307 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract SwitchTables {
+    uint256 public value;
+
+    function dense(uint256 key) external pure returns (uint256 result) {
+        assembly {
+            switch key
+            case 10 { result := 100 }
+            case 11 { result := 101 }
+            case 12 { result := 102 }
+            case 13 { result := 103 }
+            case 14 { result := 104 }
+            case 15 { result := 105 }
+            case 16 { result := 106 }
+            case 17 { result := 107 }
+            case 18 { result := 108 }
+            case 19 { result := 109 }
+            case 20 { result := 110 }
+            case 21 { result := 111 }
+            case 22 { result := 112 }
+            case 23 { result := 113 }
+            case 24 { result := 114 }
+            case 25 { result := 115 }
+            case 26 { result := 116 }
+            case 27 { result := 117 }
+            case 28 { result := 118 }
+            case 29 { result := 119 }
+            case 30 { result := 120 }
+            case 31 { result := 121 }
+            case 32 { result := 122 }
+            case 33 { result := 123 }
+            default { result := 999 }
+        }
+    }
+
+    function sparse(uint256 key) external pure returns (uint256) {
+        return sparseInternal(key);
+    }
+
+    function sparseInternal(uint256 key) internal pure returns (uint256 result) {
+        assembly {
+            switch key
+            case 0xcbf99d38 { result := 200 }
+            case 0x87d912cb { result := 201 }
+            case 0x920f5c73 { result := 202 }
+            case 0x41052a0d { result := 203 }
+            case 0x7238232f { result := 204 }
+            case 0x905f7d67 { result := 205 }
+            case 0x3b88f6c2 { result := 206 }
+            case 0xaa66aa63 { result := 207 }
+            case 0x24a75cfd { result := 208 }
+            case 0x98e9a73d { result := 209 }
+            case 0xebd25c8f { result := 210 }
+            case 0x8a67ee70 { result := 211 }
+            case 0xc43b1a78 { result := 212 }
+            case 0xebbd40a9 { result := 213 }
+            case 0x1eb6457a { result := 214 }
+            case 0xdca2fb5a { result := 215 }
+            case 0x67e648b5 { result := 216 }
+            case 0xe6e0ae36 { result := 217 }
+            case 0xcba58af7 { result := 218 }
+            case 0x6d4975a2 { result := 219 }
+            case 0x8dc714ba { result := 220 }
+            case 0x54eaadab { result := 221 }
+            case 0x10c772cc { result := 222 }
+            case 0x4e580bc4 { result := 223 }
+            case 0x965a68f5 { result := 224 }
+            case 0xd758c88e { result := 225 }
+            case 0x6d738a50 { result := 226 }
+            case 0xf02a00c9 { result := 227 }
+            case 0x40bcff2a { result := 228 }
+            case 0x5fb43592 { result := 229 }
+            case 0x3d492ec4 { result := 230 }
+            case 0x1f49dbe7 { result := 231 }
+            default { result := 999 }
+        }
+    }
+
+    function f00() external {
+        value = 0;
+    }
+
+    function f01() external {
+        value = 1;
+    }
+
+    function f02() external {
+        value = 2;
+    }
+
+    function f03() external {
+        value = 3;
+    }
+
+    function f04() external {
+        value = 4;
+    }
+
+    function f05() external {
+        value = 5;
+    }
+
+    function f06() external {
+        value = 6;
+    }
+
+    function f07() external {
+        value = 7;
+    }
+
+    function f08() external {
+        value = 8;
+    }
+
+    function f09() external {
+        value = 9;
+    }
+
+    function f10() external {
+        value = 10;
+    }
+
+    function f11() external {
+        value = 11;
+    }
+
+    function f12() external {
+        value = 12;
+    }
+
+    function f13() external {
+        value = 13;
+    }
+
+    function f14() external {
+        value = 14;
+    }
+
+    function f15() external {
+        value = 15;
+    }
+
+    function f16() external {
+        value = 16;
+    }
+
+    function f17() external {
+        value = 17;
+    }
+
+    function f18() external {
+        value = 18;
+    }
+
+    function f19() external {
+        value = 19;
+    }
+
+    function f20() external {
+        value = 20;
+    }
+
+    function f21() external {
+        value = 21;
+    }
+
+    function f22() external {
+        value = 22;
+    }
+
+    function f23() external {
+        value = 23;
+    }
+
+    function f24() external {
+        value = 24;
+    }
+
+    function f25() external {
+        value = 25;
+    }
+
+    function f26() external {
+        value = 26;
+    }
+
+    function f27() external {
+        value = 27;
+    }
+
+    function f28() external {
+        value = 28;
+    }
+
+    function f29() external {
+        value = 29;
+    }
+
+    function f30() external {
+        value = 30;
+    }
+
+    function f31() external {
+        value = 31;
+    }
+}
+
+contract SwitchTablesTest {
+    SwitchTables tables;
+
+    function setUp() public {
+        tables = new SwitchTables();
+    }
+
+    function testBucketDispatch() public {
+        tables.f00();
+        assert(tables.value() == 0);
+        tables.f01();
+        assert(tables.value() == 1);
+        tables.f02();
+        assert(tables.value() == 2);
+        tables.f03();
+        assert(tables.value() == 3);
+        tables.f04();
+        assert(tables.value() == 4);
+        tables.f05();
+        assert(tables.value() == 5);
+        tables.f06();
+        assert(tables.value() == 6);
+        tables.f07();
+        assert(tables.value() == 7);
+        tables.f08();
+        assert(tables.value() == 8);
+        tables.f09();
+        assert(tables.value() == 9);
+        tables.f10();
+        assert(tables.value() == 10);
+        tables.f11();
+        assert(tables.value() == 11);
+        tables.f12();
+        assert(tables.value() == 12);
+        tables.f13();
+        assert(tables.value() == 13);
+        tables.f14();
+        assert(tables.value() == 14);
+        tables.f15();
+        assert(tables.value() == 15);
+        tables.f16();
+        assert(tables.value() == 16);
+        tables.f17();
+        assert(tables.value() == 17);
+        tables.f18();
+        assert(tables.value() == 18);
+        tables.f19();
+        assert(tables.value() == 19);
+        tables.f20();
+        assert(tables.value() == 20);
+        tables.f21();
+        assert(tables.value() == 21);
+        tables.f22();
+        assert(tables.value() == 22);
+        tables.f23();
+        assert(tables.value() == 23);
+        tables.f24();
+        assert(tables.value() == 24);
+        tables.f25();
+        assert(tables.value() == 25);
+        tables.f26();
+        assert(tables.value() == 26);
+        tables.f27();
+        assert(tables.value() == 27);
+        tables.f28();
+        assert(tables.value() == 28);
+        tables.f29();
+        assert(tables.value() == 29);
+        tables.f30();
+        assert(tables.value() == 30);
+        tables.f31();
+        assert(tables.value() == 31);
+    }
+
+    function testBucketDispatchMiss() public {
+        (bool firstBucket,) = address(tables).call(hex"00000000");
+        assert(!firstBucket);
+        (bool lastBucket,) = address(tables).call(hex"00000026");
+        assert(!lastBucket);
+        (bool interiorBucket,) = address(tables).call(hex"ffffffff");
+        assert(!interiorBucket);
+    }
+
+    function testDenseSwitch() public view {
+        assert(tables.dense(9) == 999);
+        assert(tables.dense(10) == 100);
+        assert(tables.dense(21) == 111);
+        assert(tables.dense(33) == 123);
+        assert(tables.dense(34) == 999);
+    }
+
+    function testSparseInternalSwitch() public view {
+        assert(tables.sparse(0xcbf99d38) == 200);
+        assert(tables.sparse(0x67e648b5) == 216);
+        assert(tables.sparse(0x1f49dbe7) == 231);
+        assert(tables.sparse(1) == 999);
+    }
+}
diff --git a/tests/ui/codegen/evm-ir/none/indexed_jump.evmir b/tests/ui/codegen/evm-ir/none/indexed_jump.evmir
new file mode 100644
index 000000000..02fd52393
--- /dev/null
+++ b/tests/ui/codegen/evm-ir/none/indexed_jump.evmir
@@ -0,0 +1,9 @@
+@module indexed
+
+bb0:
+  push 1
+  indexed_jump bb1, bb2
+bb1:
+  stop
+bb2:
+  invalid
diff --git a/tests/ui/codegen/evm-ir/none/indexed_jump.stdout b/tests/ui/codegen/evm-ir/none/indexed_jump.stdout
new file mode 100644
index 000000000..4c1274b0a
--- /dev/null
+++ b/tests/ui/codegen/evm-ir/none/indexed_jump.stdout
@@ -0,0 +1,11 @@
+- // === ROOT/tests/ui/codegen/evm-ir/none/indexed_jump.evmir (before none) ===
++ // === ROOT/tests/ui/codegen/evm-ir/none/indexed_jump.evmir (after none) ===
+  @module indexed
+  bb0:
+    push 1
+    indexed_jump bb1, bb2
+  bb1:
+    stop
+  bb2:
+    invalid
+  
diff --git a/tests/ui/codegen/lowering/revert_error_helper.stdout b/tests/ui/codegen/lowering/revert_error_helper.stdout
index f71800d7b..7bc99d4ae 100644
--- a/tests/ui/codegen/lowering/revert_error_helper.stdout
+++ b/tests/ui/codegen/lowering/revert_error_helper.stdout
@@ -102,58 +102,65 @@ bb0:
   push 64
   mstore
   callvalue
-  push bb8
+  push bb9
   jumpi
   calldatasize
   iszero
-  push bb8
+  push bb9
   jumpi
   push 0
   calldataload
   push 224
   shr
   dup1
-  push 0xc4186a6
-  eq
-  push bb24
-  jumpi
-  dup1
-  push 0x17a0525e
-  eq
-  push bb29
+  push 0x9927bee4
+  gt
+  push bb3
   jumpi
   dup1
   push 0x9927bee4
   eq
-  push bb19
+  push bb20
   jumpi
   dup1
   push 0x9af992c0
   eq
-  push bb14
+  push bb15
   jumpi
   dup1
   push 0x9ee36b07
   eq
-  push bb9
+  push bb10
   jumpi
-  jump bb8
-bb8 [cold]:
+  jump bb9
+bb9 [cold]:
   push 0
   dup1
   revert
-bb9:
+bb3:
+  dup1
+  push 0xc4186a6
+  eq
+  push bb25
+  jumpi
+  dup1
+  push 0x17a0525e
+  eq
+  push bb30
+  jumpi
+  jump bb9
+bb10:
   calldatasize
   push 4
   swap1
   sub
   push 32
   sgt
-  push bb8
+  push bb9
   jumpi
-  push bb38
-  jump bb37
-bb37:
+  push bb39
+  jump bb38
+bb38:
   push 0
   push 128
   mstore
@@ -164,14 +171,14 @@ bb37:
   iszero
   swap1
   jump
-bb13 [cold]:
+bb14 [cold]:
   push 2
   push 288
   mstore
   push 0x3339
   push 240
-  jump bb36
-bb36 [cold]:
+  jump bb37
+bb37 [cold]:
   shl
   push 320
   mstore
@@ -194,75 +201,75 @@ bb36 [cold]:
   push 100
   push 0
   revert
-bb14:
+bb15:
   calldatasize
   push 4
   swap1
   sub
   push 32
   sgt
-  push bb8
+  push bb9
   jumpi
-  push bb39
-  jump bb37
-bb18 [cold]:
+  push bb40
+  jump bb38
+bb19 [cold]:
   push 11
   push 288
   mstore
   push 0x6c69746572616c206d7367
   push 168
-  jump bb36
-bb19:
+  jump bb37
+bb20:
   calldatasize
   push 4
   swap1
   sub
   push 32
   sgt
-  push bb8
+  push bb9
   jumpi
-  push bb40
-  jump bb37
-bb23 [cold]:
+  push bb41
+  jump bb38
+bb24 [cold]:
   push 15
   push 288
   mstore
   push 0x6c6f63616c2d636f6e73742d6d7367
   push 136
-  jump bb36
-bb24:
+  jump bb37
+bb25:
   calldatasize
   push 4
   swap1
   sub
   push 32
   sgt
-  push bb8
+  push bb9
   jumpi
-  push bb41
-  jump bb37
-bb29:
+  push bb42
+  jump bb38
+bb30:
   calldatasize
   push 4
   swap1
   sub
   push 32
   sgt
-  push bb8
+  push bb9
   jumpi
-  push bb42
-  jump bb37
-bb33 [cold]:
+  push bb43
+  jump bb38
+bb34 [cold]:
   push 11
   push 288
   mstore
   push 0x7265766572742d70617468
   push 168
+  jump bb37
+bb39:
+  push bb14
   jump bb36
-bb38:
-  push bb13
-  jump bb35
-bb35:
+bb36:
   jumpi
   push 4
   calldataload
@@ -271,19 +278,19 @@ bb35:
   push 32
   push 128
   return
-bb39:
-  push bb18
-  jump bb35
 bb40:
-  push bb23
-  jump bb35
+  push bb19
+  jump bb36
 bb41:
-  push bb28
-  jump bb35
+  push bb24
+  jump bb36
 bb42:
-  push bb33
-  jump bb35
-bb28 [cold]:
+  push bb29
+  jump bb36
+bb43:
+  push bb34
+  jump bb36
+bb29 [cold]:
   push 64
   mload
   dup1
diff --git a/tests/ui/codegen/lowering/storage_bytes_member.stdout b/tests/ui/codegen/lowering/storage_bytes_member.stdout
index e7fcd5da8..bdd13cedb 100644
--- a/tests/ui/codegen/lowering/storage_bytes_member.stdout
+++ b/tests/ui/codegen/lowering/storage_bytes_member.stdout
@@ -5,81 +5,88 @@ bb0:
   push 64
   mstore
   callvalue
-  push bb9
+  push bb10
   jumpi
   calldatasize
   iszero
-  push bb9
+  push bb10
   jumpi
   push 0
   calldataload
   push 224
   shr
   dup1
-  push 0x4407bb95
-  eq
-  push bb10
-  jumpi
-  dup1
-  push 0x53b8a6c6
-  eq
-  push bb32
-  jumpi
-  dup1
-  push 0x56d88e27
-  eq
-  push bb44
+  push 0x72bd964d
+  gt
+  push bb3
   jumpi
   dup1
   push 0x72bd964d
   eq
-  push bb61
+  push bb62
   jumpi
   dup1
   push 0xbee6975a
   eq
-  push bb52
+  push bb53
   jumpi
   dup1
   push 0xe0886f90
   eq
-  push bb46
+  push bb47
   jumpi
-  jump bb9
-bb9 [cold]:
+  jump bb10
+bb10 [cold]:
   push 0
   dup1
   revert
-bb24 [cold]:
+bb25 [cold]:
   push 0x4e487b71
   push 224
   shl
   push 0
   mstore
   push 17
-  jump bb71
-bb71 [cold]:
+  jump bb72
+bb72 [cold]:
   push 4
   mstore
   push 36
   push 0
   revert
-bb70 [cold]:
+bb71 [cold]:
   push 0x4e487b71
   push 224
   shl
   push 0
   mstore
   push 50
-  jump bb71
-bb10:
+  jump bb72
+bb3:
+  dup1
+  push 0x4407bb95
+  eq
+  push bb11
+  jumpi
+  dup1
+  push 0x53b8a6c6
+  eq
+  push bb33
+  jumpi
+  dup1
+  push 0x56d88e27
+  eq
+  push bb45
+  jumpi
+  jump bb10
+bb11:
   calldatasize
   push 4
   swap1
   sub
   push 64
   sgt
-  push bb9
+  push bb10
   jumpi
   push 4
   calldataload
@@ -87,7 +94,7 @@ bb10:
   dup2
   and
   sub
-  push bb9
+  push bb10
   jumpi
   push 36
   calldataload
@@ -95,7 +102,7 @@ bb10:
   dup2
   and
   sub
-  push bb9
+  push bb10
   jumpi
   caller
   push 0
@@ -122,15 +129,15 @@ bb10:
   mstore
   pop
   push 0
-  jump bb15
-bb15:
+  jump bb16
+bb16:
   push 36
   calldataload
   gt
-  push bb19
+  push bb20
   jumpi
   stop
-bb17:
+bb18:
   push 128
   mload
   push 1
@@ -154,7 +161,7 @@ bb17:
   swap2
   pop
   pop
-  push bb24
+  push bb25
   jumpi
   push 416
   mload
@@ -165,15 +172,15 @@ bb17:
   mstore
   push 416
   mload
-  jump bb15
-bb19:
+  jump bb16
+bb20:
   push 256
   mload
   push 0x420
   mstore
-  push bb20
-  jump bb63
-bb63:
+  push bb21
+  jump bb64
+bb64:
   push 0x420
   mload
   sload
@@ -283,7 +290,7 @@ bb63:
   pop
   pop
   pop
-  push bb65
+  push bb66
   jumpi
   push 255
   not
@@ -293,14 +300,14 @@ bb63:
   push 0x500
   mload
   mstore
-  jump bb66
-bb66:
+  jump bb67
+bb67:
   push 0x4e0
   mload
   push 0x440
   mstore
   jump
-bb20:
+bb21:
   push 0x440
   mload
   dup1
@@ -322,7 +329,7 @@ bb20:
   mstore
   dup2
   lt
-  push bb23
+  push bb24
   jumpi
   push 32
   dup3
@@ -427,7 +434,7 @@ bb20:
   pop
   pop
   pop
-  push bb24
+  push bb25
   jumpi
   push 255
   push 640
@@ -586,7 +593,7 @@ bb20:
   pop
   pop
   pop
-  push bb26
+  push bb27
   jumpi
   push 320
   mload
@@ -618,8 +625,8 @@ bb20:
   push 256
   mload
   sstore
-  jump bb29
-bb29:
+  jump bb30
+bb30:
   push 352
   mload
   dup1
@@ -630,8 +637,8 @@ bb29:
   mstore
   push 352
   mload
-  jump bb30
-bb30:
+  jump bb31
+bb31:
   push 512
   mload
   dup1
@@ -639,7 +646,7 @@ bb30:
   mstore
   gt
   iszero
-  push bb17
+  push bb18
   jumpi
   push 224
   mload
@@ -668,8 +675,8 @@ bb30:
   mstore
   push 736
   mload
-  jump bb30
-bb26:
+  jump bb31
+bb27:
   push 288
   mload
   dup1
@@ -687,8 +694,8 @@ bb26:
   mload
   mstore
   push 0
-  jump bb27
-bb27:
+  jump bb28
+bb28:
   push 352
   mload
   dup1
@@ -696,7 +703,7 @@ bb27:
   mstore
   gt
   iszero
-  push bb29
+  push bb30
   jumpi
   push 224
   mload
@@ -735,8 +742,8 @@ bb27:
   mstore
   push 672
   mload
-  jump bb27
-bb32:
+  jump bb28
+bb33:
   caller
   push 0
   mstore
@@ -761,9 +768,9 @@ bb32:
   push 0x420
   mstore
   pop
-  push bb33
-  jump bb63
-bb33:
+  push bb34
+  jump bb64
+bb34:
   push 0x440
   mload
   dup1
@@ -774,7 +781,7 @@ bb33:
   push 384
   mstore
   iszero
-  push bb35
+  push bb36
   jumpi
   push 1
   push 384
@@ -995,7 +1002,7 @@ bb33:
   pop
   pop
   pop
-  push bb37
+  push bb38
   jumpi
   push 320
   mload
@@ -1027,8 +1034,8 @@ bb33:
   push 224
   mload
   sstore
-  jump bb40
-bb40:
+  jump bb41
+bb41:
   push 288
   mload
   dup1
@@ -1039,8 +1046,8 @@ bb40:
   mstore
   push 288
   mload
-  jump bb41
-bb41:
+  jump bb42
+bb42:
   push 416
   mload
   dup1
@@ -1048,7 +1055,7 @@ bb41:
   mstore
   gt
   iszero
-  push bb43
+  push bb44
   jumpi
   push 192
   mload
@@ -1077,8 +1084,8 @@ bb41:
   mstore
   push 608
   mload
-  jump bb41
-bb37:
+  jump bb42
+bb38:
   push 256
   mload
   dup1
@@ -1096,8 +1103,8 @@ bb37:
   mload
   mstore
   push 0
-  jump bb38
-bb38:
+  jump bb39
+bb39:
   push 288
   mload
   dup1
@@ -1105,7 +1112,7 @@ bb38:
   mstore
   gt
   iszero
-  push bb40
+  push bb41
   jumpi
   push 192
   mload
@@ -1144,8 +1151,8 @@ bb38:
   mstore
   push 544
   mload
-  jump bb38
-bb44:
+  jump bb39
+bb45:
   push 0
   push 128
   mstore
@@ -1164,30 +1171,30 @@ bb44:
   push 0x420
   mstore
   pop
-  push bb45
-  jump bb63
-bb45:
+  push bb46
+  jump bb64
+bb46:
   push 0x440
   mload
   dup1
   push 224
   mstore
   mload
-  jump bb72
-bb72:
+  jump bb73
+bb73:
   push 128
   mstore
   push 32
   push 128
   return
-bb46:
+bb47:
   calldatasize
   push 4
   swap1
   sub
   push 32
   sgt
-  push bb9
+  push bb10
   jumpi
   push 0
   push 128
@@ -1207,9 +1214,9 @@ bb46:
   push 0x420
   mstore
   pop
-  push bb48
-  jump bb63
-bb48:
+  push bb49
+  jump bb64
+bb49:
   push 0x440
   mload
   dup1
@@ -1220,7 +1227,7 @@ bb48:
   calldataload
   lt
   iszero
-  push bb70
+  push bb71
   jumpi
   push 32
   push 224
@@ -1234,15 +1241,15 @@ bb48:
   push 248
   shl
   and
-  jump bb72
-bb52:
+  jump bb73
+bb53:
   calldatasize
   push 4
   swap1
   sub
   push 64
   sgt
-  push bb9
+  push bb10
   jumpi
   push 36
   calldataload
@@ -1252,7 +1259,7 @@ bb52:
   dup2
   and
   sub
-  push bb9
+  push bb10
   jumpi
   caller
   push 0
@@ -1314,7 +1321,7 @@ bb52:
   calldataload
   lt
   iszero
-  push bb70
+  push bb71
   jumpi
   push 36
   calldataload
@@ -1328,7 +1335,7 @@ bb52:
   pop
   pop
   pop
-  push bb59
+  push bb60
   jumpi
   push 4
   calldataload
@@ -1356,10 +1363,10 @@ bb52:
   push 128
   mload
   sstore
-  jump bb43
-bb43:
+  jump bb44
+bb44:
   stop
-bb59:
+bb60:
   push 128
   mload
   dup1
@@ -1408,8 +1415,8 @@ bb59:
   or
   swap1
   sstore
-  jump bb43
-bb61:
+  jump bb44
+bb62:
   push 0
   push 128
   mstore
@@ -1428,9 +1435,9 @@ bb61:
   push 0x420
   mstore
   pop
-  push bb62
-  jump bb63
-bb62:
+  push bb63
+  jump bb64
+bb63:
   push 0x440
   mload
   dup1
@@ -1489,7 +1496,7 @@ bb62:
   add
   dup2
   return
-bb65:
+bb66:
   push 0x420
   mload
   push 0x4c0
@@ -1510,8 +1517,8 @@ bb65:
   mload
   swap2
   swap1
-  jump bb67
-bb67:
+  jump bb68
+bb68:
   dup1
   push 0x560
   mstore
@@ -1525,7 +1532,7 @@ bb67:
   pop
   pop
   iszero
-  push bb66
+  push bb67
   jumpi
   push 0x580
   mload
@@ -1551,8 +1558,8 @@ bb67:
   swap1
   swap2
   swap1
-  jump bb67
-bb23 [cold]:
+  jump bb68
+bb24 [cold]:
   push 0x4e487b71
   push 224
   shl
@@ -1561,12 +1568,12 @@ bb23 [cold]:
   pop
   pop
   push 65
-  jump bb71
-bb35 [cold]:
+  jump bb72
+bb36 [cold]:
   push 0x4e487b71
   push 224
   shl
   push 0
   mstore
   push 49
-  jump bb71
+  jump bb72
diff --git a/tests/ui/codegen/lowering/switch_bucket_dispatch.sol b/tests/ui/codegen/lowering/switch_bucket_dispatch.sol
new file mode 100644
index 000000000..30598cf71
--- /dev/null
+++ b/tests/ui/codegen/lowering/switch_bucket_dispatch.sol
@@ -0,0 +1,38 @@
+//@ compile-flags: -Zcodegen -Zdump=evm-ir-runtime
+//@ filecheck: --check-prefix=TABLE
+
+// TABLE: indexed_jump
+contract SwitchBucketDispatch {
+    function f00() external {}
+    function f01() external {}
+    function f02() external {}
+    function f03() external {}
+    function f04() external {}
+    function f05() external {}
+    function f06() external {}
+    function f07() external {}
+    function f08() external {}
+    function f09() external {}
+    function f10() external {}
+    function f11() external {}
+    function f12() external {}
+    function f13() external {}
+    function f14() external {}
+    function f15() external {}
+    function f16() external {}
+    function f17() external {}
+    function f18() external {}
+    function f19() external {}
+    function f20() external {}
+    function f21() external {}
+    function f22() external {}
+    function f23() external {}
+    function f24() external {}
+    function f25() external {}
+    function f26() external {}
+    function f27() external {}
+    function f28() external {}
+    function f29() external {}
+    function f30() external {}
+    function f31() external {}
+}
diff --git a/tests/ui/codegen/lowering/switch_bucket_dispatch.stdout b/tests/ui/codegen/lowering/switch_bucket_dispatch.stdout
new file mode 100644
index 000000000..0caf4f29b
--- /dev/null
+++ b/tests/ui/codegen/lowering/switch_bucket_dispatch.stdout
@@ -0,0 +1,249 @@
+// === ROOT/tests/ui/codegen/lowering/switch_bucket_dispatch.sol:SwitchBucketDispatch (runtime) ===
+@module runtime
+bb0:
+  push 128
+  push 64
+  mstore
+  callvalue
+  push bb59
+  jumpi
+  calldatasize
+  iszero
+  push bb59
+  jumpi
+  push 0
+  calldataload
+  push 224
+  shr
+  dup1
+  push 40
+  swap1
+  mod
+  indexed_jump bb62, bb63, bb64, bb65, bb66, bb67, bb68, bb69, bb70, bb71, bb72, bb73, bb74, bb75, bb76, bb77, bb78, bb79, bb80, bb81, bb82, bb83, bb84, bb85, bb86, bb87, bb88, bb89, bb90, bb91, bb92, bb93, bb94, bb95, bb96, bb97, bb98, bb99, bb100, bb101
+bb60:
+  stop
+bb3:
+  dup1
+  push 0xcbf99d38
+  jump bb61
+bb61:
+  eq
+  push bb60
+  jumpi
+  jump bb59
+bb59 [cold]:
+  push 0
+  dup1
+  revert
+bb4:
+  dup1
+  push 0x87d912cb
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0x920f5c73
+  jump bb61
+bb5:
+  dup1
+  push 0x41052a0d
+  jump bb61
+bb6:
+  dup1
+  push 0x7238232f
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0x905f7d67
+  jump bb61
+bb7:
+  dup1
+  push 0x3b88f6c2
+  jump bb61
+bb8:
+  dup1
+  push 0xaa66aa63
+  jump bb61
+bb9:
+  dup1
+  push 0x24a75cfd
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0x98e9a73d
+  jump bb61
+bb10:
+  dup1
+  push 0xebd25c8f
+  jump bb61
+bb11:
+  dup1
+  push 0x8a67ee70
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0xc43b1a78
+  jump bb61
+bb12:
+  dup1
+  push 0xebbd40a9
+  jump bb61
+bb13:
+  dup1
+  push 0x1eb6457a
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0xdca2fb5a
+  jump bb61
+bb14:
+  dup1
+  push 0x67e648b5
+  jump bb61
+bb15:
+  dup1
+  push 0xe6e0ae36
+  jump bb61
+bb16:
+  dup1
+  push 0xcba58af7
+  jump bb61
+bb17:
+  dup1
+  push 0x6d4975a2
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0x8dc714ba
+  jump bb61
+bb18:
+  dup1
+  push 0x54eaadab
+  jump bb61
+bb19:
+  dup1
+  push 0x10c772cc
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0x4e580bc4
+  jump bb61
+bb20:
+  dup1
+  push 0x965a68f5
+  jump bb61
+bb21:
+  dup1
+  push 0xd758c88e
+  jump bb61
+bb22:
+  dup1
+  push 0x6d738a50
+  jump bb61
+bb23:
+  dup1
+  push 0xf02a00c9
+  jump bb61
+bb24:
+  dup1
+  push 0x40bcff2a
+  eq
+  push bb60
+  jumpi
+  dup1
+  push 0x5fb43592
+  jump bb61
+bb25:
+  dup1
+  push 0x3d492ec4
+  jump bb61
+bb26:
+  dup1
+  push 0x1f49dbe7
+  jump bb61
+bb62:
+  jump bb3
+bb63:
+  jump bb59
+bb64:
+  jump bb59
+bb65:
+  jump bb4
+bb66:
+  jump bb59
+bb67:
+  jump bb5
+bb68:
+  jump bb59
+bb69:
+  jump bb6
+bb70:
+  jump bb59
+bb71:
+  jump bb59
+bb72:
+  jump bb7
+bb73:
+  jump bb8
+bb74:
+  jump bb59
+bb75:
+  jump bb9
+bb76:
+  jump bb59
+bb77:
+  jump bb10
+bb78:
+  jump bb11
+bb79:
+  jump bb12
+bb80:
+  jump bb13
+bb81:
+  jump bb59
+bb82:
+  jump bb59
+bb83:
+  jump bb14
+bb84:
+  jump bb15
+bb85:
+  jump bb16
+bb86:
+  jump bb59
+bb87:
+  jump bb59
+bb88:
+  jump bb17
+bb89:
+  jump bb18
+bb90:
+  jump bb19
+bb91:
+  jump bb20
+bb92:
+  jump bb21
+bb93:
+  jump bb59
+bb94:
+  jump bb22
+bb95:
+  jump bb23
+bb96:
+  jump bb24
+bb97:
+  jump bb59
+bb98:
+  jump bb25
+bb99:
+  jump bb59
+bb100:
+  jump bb59
+bb101:
+  jump bb26
diff --git a/tests/ui/codegen/lowering/switch_dense_table.sol b/tests/ui/codegen/lowering/switch_dense_table.sol
new file mode 100644
index 000000000..e01d63c01
--- /dev/null
+++ b/tests/ui/codegen/lowering/switch_dense_table.sol
@@ -0,0 +1,41 @@
+//@ compile-flags: -Zcodegen -O size -Zdump=evm-ir-runtime
+//@ filecheck: --check-prefix=TABLE
+
+// TABLE: push 10
+// TABLE-NEXT: swap1
+// TABLE-NEXT: sub
+// TABLE: indexed_jump
+contract SwitchDenseTable {
+    uint256 value;
+
+    function select(uint256 key) external {
+        assembly {
+            switch key
+            case 10 { sstore(0, 10) }
+            case 11 { sstore(0, 11) }
+            case 12 { sstore(0, 12) }
+            case 13 { sstore(0, 13) }
+            case 14 { sstore(0, 14) }
+            case 15 { sstore(0, 15) }
+            case 16 { sstore(0, 16) }
+            case 17 { sstore(0, 17) }
+            case 18 { sstore(0, 18) }
+            case 19 { sstore(0, 19) }
+            case 20 { sstore(0, 20) }
+            case 21 { sstore(0, 21) }
+            case 22 { sstore(0, 22) }
+            case 23 { sstore(0, 23) }
+            case 24 { sstore(0, 24) }
+            case 25 { sstore(0, 25) }
+            case 26 { sstore(0, 26) }
+            case 27 { sstore(0, 27) }
+            case 28 { sstore(0, 28) }
+            case 29 { sstore(0, 29) }
+            case 30 { sstore(0, 30) }
+            case 31 { sstore(0, 31) }
+            case 32 { sstore(0, 32) }
+            case 33 { sstore(0, 33) }
+            default { sstore(0, 255) }
+        }
+    }
+}
diff --git a/tests/ui/codegen/lowering/switch_dense_table.stdout b/tests/ui/codegen/lowering/switch_dense_table.stdout
new file mode 100644
index 000000000..07633176a
--- /dev/null
+++ b/tests/ui/codegen/lowering/switch_dense_table.stdout
@@ -0,0 +1,173 @@
+// === ROOT/tests/ui/codegen/lowering/switch_dense_table.sol:SwitchDenseTable (runtime) ===
+@module runtime
+bb0:
+  push 128
+  push 64
+  mstore
+  callvalue
+  push bb4
+  jumpi
+  calldatasize
+  iszero
+  push bb4
+  jumpi
+  push 0
+  calldataload
+  push 224
+  shr
+  dup1
+  push 0x839a19d9
+  sub
+  push bb4
+  jumpi
+  calldatasize
+  push 4
+  swap1
+  sub
+  push 32
+  sgt
+  push bb4
+  jumpi
+  push 4
+  calldataload
+  push 10
+  swap1
+  sub
+  dup1
+  push 24
+  gt
+  push bb7
+  jumpi
+  pop
+  push 255
+  jump bb34
+bb34:
+  push 0
+  sstore
+  stop
+bb4 [cold]:
+  push 0
+  dup1
+  revert
+bb7:
+  indexed_jump bb35, bb36, bb37, bb38, bb39, bb40, bb41, bb42, bb43, bb44, bb45, bb46, bb47, bb48, bb49, bb50, bb51, bb52, bb53, bb54, bb55, bb56, bb57, bb58
+bb10:
+  push 10
+  jump bb34
+bb11:
+  push 11
+  jump bb34
+bb12:
+  push 12
+  jump bb34
+bb13:
+  push 13
+  jump bb34
+bb14:
+  push 14
+  jump bb34
+bb15:
+  push 15
+  jump bb34
+bb16:
+  push 16
+  jump bb34
+bb17:
+  push 17
+  jump bb34
+bb18:
+  push 18
+  jump bb34
+bb19:
+  push 19
+  jump bb34
+bb20:
+  push 20
+  jump bb34
+bb21:
+  push 21
+  jump bb34
+bb22:
+  push 22
+  jump bb34
+bb23:
+  push 23
+  jump bb34
+bb24:
+  push 24
+  jump bb34
+bb25:
+  push 25
+  jump bb34
+bb26:
+  push 26
+  jump bb34
+bb27:
+  push 27
+  jump bb34
+bb28:
+  push 28
+  jump bb34
+bb29:
+  push 29
+  jump bb34
+bb30:
+  push 30
+  jump bb34
+bb31:
+  push 31
+  jump bb34
+bb32:
+  push 32
+  jump bb34
+bb33:
+  push 33
+  jump bb34
+bb35:
+  jump bb10
+bb36:
+  jump bb11
+bb37:
+  jump bb12
+bb38:
+  jump bb13
+bb39:
+  jump bb14
+bb40:
+  jump bb15
+bb41:
+  jump bb16
+bb42:
+  jump bb17
+bb43:
+  jump bb18
+bb44:
+  jump bb19
+bb45:
+  jump bb20
+bb46:
+  jump bb21
+bb47:
+  jump bb22
+bb48:
+  jump bb23
+bb49:
+  jump bb24
+bb50:
+  jump bb25
+bb51:
+  jump bb26
+bb52:
+  jump bb27
+bb53:
+  jump bb28
+bb54:
+  jump bb29
+bb55:
+  jump bb30
+bb56:
+  jump bb31
+bb57:
+  jump bb32
+bb58:
+  jump bb33