diff --git a/crates/compiler/codegen/src/builder.rs b/crates/compiler/codegen/src/builder.rs
index 03dac30b..87eb4f9d 100644
--- a/crates/compiler/codegen/src/builder.rs
+++ b/crates/compiler/codegen/src/builder.rs
@@ -45,7 +45,7 @@ pub struct CasmBuilder {
     /// Labels that need to be resolved
     pub(super) labels: Vec<Label>,
     /// Current function layout for offset lookups
-    pub(crate) layout: FunctionLayout,
+    pub layout: FunctionLayout,
     /// Counter for generating unique labels
     pub(super) label_counter: usize,
     /// Highest fp+ offset that has been written to (for optimization tracking)
@@ -96,7 +96,7 @@ impl CasmBuilder {
     /// Generate type-aware assignment instruction
     ///
     /// Handles assignments for all types including aggregates (structs, tuples)
-    pub(crate) fn assign(
+    pub fn assign(
         &mut self,
         dest: ValueId,
         source: Value,
@@ -194,7 +194,7 @@ impl CasmBuilder {
     }
 
     /// Generate unary operation instruction
-    pub(crate) fn unary_op(
+    pub fn unary_op(
         &mut self,
         op: UnaryOp,
         dest: ValueId,
@@ -228,11 +228,71 @@ impl CasmBuilder {
         Ok(())
     }
 
+    /// Load a value from memory through a pointer
+    ///
+    /// Loads slots from [[ptr_base] + 0..size] into dest. Size is inferred from dest's layout.
+    pub fn load_from_memory(
+        &mut self,
+        dest: ValueId,
+        ptr_base: ValueId,
+        size: usize,
+    ) -> CodegenResult<()> {
+        let base_off = self.layout.get_offset(ptr_base)?;
+        let dest_off = self.layout.allocate_local(dest, size)?;
+
+        for slot in 0..size {
+            self.store_from_double_deref_fp_imm(
+                base_off,
+                slot as i32,
+                dest_off + slot as i32,
+                format!(
+                    "[fp + {}] = [[fp + {}] + {}] (load limb {}/{})",
+                    dest_off + slot as i32,
+                    base_off,
+                    slot,
+                    slot + 1,
+                    size
+                ),
+            );
+        }
+
+        Ok(())
+    }
+
+    /// Store a value to memory through a pointer
+    ///
+    /// Stores slots to [[ptr_base] + 0..size] from value. Size is inferred from value's layout.
+    pub fn store_to_memory(&mut self, ptr_base: ValueId, value: ValueId) -> CodegenResult<()> {
+        let base_off = self.layout.get_offset(ptr_base)?;
+        let value_off = self.layout.get_offset(value)?;
+
+        // Get size from value's layout
+        let size = self.layout.get_value_size(value);
+
+        for slot in 0..size {
+            self.store_to_double_deref_fp_imm(
+                value_off + slot as i32,
+                base_off,
+                slot as i32,
+                format!(
+                    "[[fp + {}] + {}] = [fp + {}] (store limb {}/{})",
+                    base_off,
+                    slot,
+                    value_off + slot as i32,
+                    slot + 1,
+                    size
+                ),
+            );
+        }
+
+        Ok(())
+    }
+
     /// Generate a binary operation instruction
     ///
     /// If target_offset is provided, writes directly to that location.
     /// Otherwise, allocates a new local variable.
-    pub(crate) fn binary_op(
+    pub fn binary_op(
         &mut self,
         op: BinaryOp,
         dest: ValueId,
@@ -332,6 +392,7 @@ impl CasmBuilder {
         &mut self.instructions
     }
 
+    #[cfg(test)]
     /// Get the labels
     pub(crate) fn labels(&self) -> &[Label] {
         &self.labels
diff --git a/crates/compiler/codegen/src/builder/calls.rs b/crates/compiler/codegen/src/builder/calls.rs
index d504f684..a2bd275e 100644
--- a/crates/compiler/codegen/src/builder/calls.rs
+++ b/crates/compiler/codegen/src/builder/calls.rs
@@ -9,7 +9,7 @@ use stwo_prover::core::fields::m31::M31;
 
 impl super::CasmBuilder {
     /// Shared lowering for all call flavors (void, single, multiple).
-    pub(crate) fn lower_call(
+    pub fn lower_call(
         &mut self,
         callee_name: &str,
         args: &[Value],
diff --git a/crates/compiler/codegen/src/builder/ctrlflow.rs b/crates/compiler/codegen/src/builder/ctrlflow.rs
index ba97b552..42e7b01a 100644
--- a/crates/compiler/codegen/src/builder/ctrlflow.rs
+++ b/crates/compiler/codegen/src/builder/ctrlflow.rs
@@ -8,7 +8,7 @@ use stwo_prover::core::fields::m31::M31;
 impl super::CasmBuilder {
     /// Generates an unconditional jump to a label.
     /// Uses a relative jump (offset resolved in a later pass).
-    pub(crate) fn jump(&mut self, target_label: &str) {
+    pub fn jump(&mut self, target_label: &str) {
         let instr = InstructionBuilder::new(
             CasmInstr::JmpRelImm {
                 offset: M31::from(0),
@@ -22,7 +22,7 @@ impl super::CasmBuilder {
 
     /// Generates a conditional jump instruction that triggers if the value at `cond_off` is non-zero.
     /// The `target_label` is a placeholder that will be resolved to a relative offset later.
-    pub(crate) fn jnz(&mut self, condition: Value, target_label: &str) -> CodegenResult<()> {
+    pub fn jnz(&mut self, condition: Value, target_label: &str) -> CodegenResult<()> {
         // Get the condition value offset
         let cond_off = match condition {
             Value::Operand(cond_id) => self.layout.get_offset(cond_id)?,
@@ -44,7 +44,7 @@ impl super::CasmBuilder {
     }
 
     /// Generates a conditional jump based on a direct fp-relative offset.
-    pub(crate) fn jnz_offset(&mut self, cond_off: i32, target_label: &str) {
+    pub fn jnz_offset(&mut self, cond_off: i32, target_label: &str) {
         let instr = InstructionBuilder::new(
             CasmInstr::JnzFpImm {
                 cond_off: M31::from(cond_off),
@@ -58,12 +58,7 @@ impl super::CasmBuilder {
     }
 
     /// Short-circuit OR: dest = (left != 0) || (right != 0)
-    pub(super) fn sc_or(
-        &mut self,
-        dest_off: i32,
-        left: &Value,
-        right: &Value,
-    ) -> CodegenResult<()> {
+    pub fn sc_or(&mut self, dest_off: i32, left: &Value, right: &Value) -> CodegenResult<()> {
         // Initialize result to 0
         self.store_immediate(0, dest_off, "Initialize OR result to 0".to_string());
         let set_true = self.emit_new_label_name("or_true");
@@ -82,12 +77,7 @@ impl super::CasmBuilder {
     }
 
     /// Short-circuit AND: dest = (left != 0) && (right != 0)
-    pub(super) fn sc_and(
-        &mut self,
-        dest_off: i32,
-        left: &Value,
-        right: &Value,
-    ) -> CodegenResult<()> {
+    pub fn sc_and(&mut self, dest_off: i32, left: &Value, right: &Value) -> CodegenResult<()> {
         // Default to 0
         self.store_immediate(0, dest_off, format!("[fp + {dest_off}] = 0"));
         let check_right = self.emit_new_label_name("and_check_right");
@@ -132,7 +122,7 @@ impl super::CasmBuilder {
     }
 
     /// NOT: dest = ([source] == 0)
-    pub(super) fn sc_not(&mut self, dest_off: i32, source: &Value) -> CodegenResult<()> {
+    pub fn sc_not(&mut self, dest_off: i32, source: &Value) -> CodegenResult<()> {
         let set_zero = self.emit_new_label_name("not_zero");
         let end = self.emit_new_label_name("not_end");
         match source {
@@ -170,7 +160,7 @@ impl super::CasmBuilder {
     /// - When `value` is an operand, emits a JNZ.
     /// - When `value` is a literal and truthy, emits an unconditional JMP if `emit_jmp_if_const_true` is true.
     /// - Returns Some(true/false) when `value` is a constant; None when dynamic.
-    fn branch_if_nonzero_to(
+    pub fn branch_if_nonzero_to(
         &mut self,
         value: &Value,
         label: &str,
diff --git a/crates/compiler/codegen/src/builder/emit.rs b/crates/compiler/codegen/src/builder/emit.rs
index 4e6be06b..638a1c99 100644
--- a/crates/compiler/codegen/src/builder/emit.rs
+++ b/crates/compiler/codegen/src/builder/emit.rs
@@ -14,14 +14,14 @@ impl super::CasmBuilder {
     }
 
     /// Generate a fresh label name using the builder's counter.
-    pub(crate) fn emit_new_label_name(&mut self, prefix: &str) -> String {
+    pub fn emit_new_label_name(&mut self, prefix: &str) -> String {
         let label_id = self.label_counter;
         self.label_counter += 1;
         format!("{}_{}", prefix, label_id)
     }
 
     /// Add a label at the current instruction address.
-    pub(crate) fn emit_add_label(&mut self, mut label: Label) {
+    pub fn emit_add_label(&mut self, mut label: Label) {
         label.address = Some(self.instructions.len());
         self.labels.push(label);
     }
diff --git a/crates/compiler/codegen/src/generator.rs b/crates/compiler/codegen/src/generator.rs
index 20db05f4..7352c6dc 100644
--- a/crates/compiler/codegen/src/generator.rs
+++ b/crates/compiler/codegen/src/generator.rs
@@ -209,7 +209,7 @@ impl CodeGenerator {
     }
 
     /// Compile the generated code into a CompiledProgram.
-    pub(crate) fn compile(self) -> CodegenResult<Program> {
+    pub fn compile(self) -> CodegenResult<Program> {
         let instructions: Vec<cairo_m_common::Instruction> = self
             .instructions
             .iter()
@@ -256,7 +256,7 @@ impl CodeGenerator {
     }
 
     /// Calculate memory layout for variable-sized instructions
-    fn calculate_memory_layout(&mut self) -> CodegenResult<()> {
+    pub fn calculate_memory_layout(&mut self) -> CodegenResult<()> {
         self.memory_layout.clear();
         let mut current_mem_pc = 0u32;
 
@@ -344,6 +344,51 @@ impl CodeGenerator {
         Ok(out)
     }
 
+    /// Add a pre-built function from a CasmBuilder to the program
+    ///
+    /// This allows external code to build functions using CasmBuilder and add them
+    /// to the program without exposing internal fields. Used by WASM lowering.
+    pub fn add_function_from_builder(
+        &mut self,
+        mut builder: CasmBuilder,
+        params: Vec<AbiSlot>,
+        returns: Vec<AbiSlot>,
+    ) -> CodegenResult<()> {
+        let name = builder.layout.name.clone();
+        // Store layout
+        self.function_layouts
+            .insert(name.clone(), builder.layout.clone());
+
+        // Update entrypoint with current instruction offset
+        let info = EntrypointInfo {
+            pc: self.instructions.len(),
+            params,
+            returns,
+        };
+        self.function_entrypoints.insert(name, info);
+
+        // Update label counter to avoid collisions
+        self.label_counter += builder.label_counter();
+
+        // Run post-builder passes
+        passes::run_all(&mut builder)?;
+
+        // Fix label addresses to be relative to global instruction stream
+        let instruction_offset = self.instructions.len();
+        let mut corrected_labels = builder.labels;
+        for label in &mut corrected_labels {
+            if let Some(local_addr) = label.address {
+                label.address = Some(local_addr + instruction_offset);
+            }
+        }
+
+        // Append generated instructions and corrected labels
+        self.instructions.extend(builder.instructions);
+        self.labels.extend(corrected_labels);
+
+        Ok(())
+    }
+
     /// Generate code for all functions
     fn generate_all_functions(&mut self, module: &MirModule) -> CodegenResult<()> {
         for (_, function) in module.functions() {
@@ -399,36 +444,11 @@ impl CodeGenerator {
             })
             .collect::<CodegenResult<_>>()?;
 
-        let entrypoint_info = EntrypointInfo {
-            pc: self.instructions.len(),
-            params,
-            returns,
-        };
-        self.function_entrypoints
-            .insert(function.name.clone(), entrypoint_info);
-
         builder.emit_add_label(func_label);
-
         self.generate_basic_blocks(function, module, &mut builder)?;
 
-        self.label_counter += builder.label_counter();
-
-        // Run post-builder passes (deduplication, peephole opts, etc.)
-        passes::run_all(&mut builder)?;
-
-        // Fix label addresses to be relative to the global instruction stream
-        let instruction_offset = self.instructions.len();
-        let mut corrected_labels = builder.labels().to_vec();
-        for label in &mut corrected_labels {
-            if let Some(local_addr) = label.address {
-                label.address = Some(local_addr + instruction_offset);
-            }
-        }
-
-        // Append generated instructions and corrected labels
-        self.instructions
-            .extend(builder.instructions().iter().cloned());
-        self.labels.extend(corrected_labels);
+        // Use common logic to append function
+        self.add_function_from_builder(builder, params, returns)?;
 
         Ok(())
     }
@@ -1557,7 +1577,7 @@ impl CodeGenerator {
     }
 
     /// Resolve all label references (second pass)
-    fn resolve_labels(&mut self) -> CodegenResult<()> {
+    pub fn resolve_labels(&mut self) -> CodegenResult<()> {
         // Build a map of label names to their physical addresses
         let mut label_map = HashMap::new();
 
diff --git a/crates/compiler/codegen/src/layout.rs b/crates/compiler/codegen/src/layout.rs
index 30cfb34f..95ad361e 100644
--- a/crates/compiler/codegen/src/layout.rs
+++ b/crates/compiler/codegen/src/layout.rs
@@ -50,7 +50,7 @@ pub enum ValueLayout {
 /// Maps every ValueId in a function to its fp-relative memory offset.
 #[derive(Debug, Clone)]
 pub struct FunctionLayout {
-    name: String,
+    pub name: String,
     /// Maps ValueId to its memory layout.
     pub value_layouts: FxHashMap<ValueId, ValueLayout>,
     /// The total frame size needed for this function.
@@ -58,9 +58,9 @@ pub struct FunctionLayout {
     /// Number of parameters this function takes.
     pub num_parameters: usize,
     /// Number of values this function returns.
-    num_return_values: usize,
+    pub num_return_values: usize,
     /// Total number of slots required for return values (accounting for multi-slot types).
-    num_return_slots: usize,
+    pub num_return_slots: usize,
 }
 
 impl FunctionLayout {
@@ -235,7 +235,7 @@ impl FunctionLayout {
     }
 
     /// Allocates a new local variable at the next available positive offset from `fp`.
-    pub(crate) fn allocate_local(&mut self, value_id: ValueId, size: usize) -> CodegenResult<i32> {
+    pub fn allocate_local(&mut self, value_id: ValueId, size: usize) -> CodegenResult<i32> {
         // If this value is already allocated, return its offset.
         if let Some(layout) = self.value_layouts.get(&value_id) {
             return match layout {
@@ -289,7 +289,7 @@ impl FunctionLayout {
     }
 
     /// Gets the fp-relative offset for a `ValueId`.
-    pub(crate) fn get_offset(&self, value_id: ValueId) -> CodegenResult<i32> {
+    pub fn get_offset(&self, value_id: ValueId) -> CodegenResult<i32> {
         match self.value_layouts.get(&value_id) {
             Some(ValueLayout::Slot { offset }) | Some(ValueLayout::MultiSlot { offset, .. }) => {
                 Ok(*offset)
diff --git a/crates/wasm/src/loader.rs b/crates/wasm/src/loader.rs
index 36ea32b8..9f8fe495 100644
--- a/crates/wasm/src/loader.rs
+++ b/crates/wasm/src/loader.rs
@@ -115,7 +115,7 @@ mod tests {
         // Test basic loading functionality
         let wasm_bytes = parse_file("tests/test_cases/i32_arithmetic.wat").unwrap();
         let result = BlocklessDagModule::from_bytes(&wasm_bytes);
-        assert!(result.is_ok(), "Should load add.wasm successfully");
+        assert!(result.is_ok(), "Should load wat file successfully");
 
         let module = result.unwrap();
         assert!(!module.0.functions.is_empty());
diff --git a/crates/wasm/src/lowering/cfg.rs b/crates/wasm/src/lowering/cfg.rs
index 52ce77c3..2b0ab060 100644
--- a/crates/wasm/src/lowering/cfg.rs
+++ b/crates/wasm/src/lowering/cfg.rs
@@ -1,58 +1,66 @@
-use super::{wasm_type_to_mir_type, DagToMirContext, DagToMirError};
+use super::{wasm_type_to_mir_type, DagToCasmContext, DagToCasmError};
 use crate::loader::BlocklessDagModule;
 use crate::lowering::context::ActiveLoop;
-use cairo_m_compiler_mir::{Terminator, Value, ValueId};
+use cairo_m_compiler_codegen::Label;
+use cairo_m_compiler_mir::{MirType, Value, ValueId};
 use womir::loader::blockless_dag::{BlocklessDag, BreakTarget, Node, Operation, TargetType};
 use womir::loader::dag::ValueOrigin;
 
-impl DagToMirContext {
-    /// Pass 1: Preallocate all the blocks associated with DAG labels and loops
-    /// Create phi nodes for label outputs that will be populated later
-    pub(super) fn allocate_blocks_and_phi_nodes(
+pub(super) enum SolvedBreakTarget {
+    Label(String),
+    Return(Vec<Value>),
+}
+
+impl DagToCasmContext {
+    /// Generate CASM instructions from DAG nodes
+    pub(super) fn generate_instructions_from_dag(
         &mut self,
-        func: &BlocklessDag,
-    ) -> Result<(), DagToMirError> {
-        for (node_idx, node) in func.nodes.iter().enumerate() {
+        dag: &BlocklessDag,
+        module: &BlocklessDagModule,
+    ) -> Result<(), DagToCasmError> {
+        // First pass: pre-register all labels and allocate their slots
+        // This must be done separately to handle forward references where branches
+        // to a label appear before the label definition in the DAG
+        for (node_idx, node) in dag.nodes.iter().enumerate() {
             if let Operation::Label { id } = &node.operation {
-                let block_id = self.mir_function.add_basic_block();
-                self.label_map.insert(*id, block_id);
-                let mir_types = node
-                    .output_types
-                    .iter()
-                    .map(|t| wasm_type_to_mir_type(t, "unknown", "label output"))
-                    .collect::<Result<Vec<_>, _>>()?;
-                let phi_value_ids: Vec<ValueId> = self.create_phi_nodes(block_id, &mir_types);
-
-                // Map the label outputs to these phi nodes
-                for (output_idx, &phi_id) in phi_value_ids.iter().enumerate() {
+                // Register label name
+                let label_name = self.casm_builder.emit_new_label_name(".L");
+                self.label_names.insert(*id, label_name.clone());
+
+                // Allocate slots for label outputs (values flowing through this merge point)
+                let mut slots = Vec::new();
+                for (output_idx, output_type) in node.output_types.iter().enumerate() {
+                    let slot_id = self.new_typed_value_id(wasm_type_to_mir_type(
+                        output_type,
+                        &self.casm_builder.layout.name,
+                        "label output",
+                    )?);
+                    slots.push(slot_id);
+
+                    // Register the slot as this label node's output
                     self.insert_value(
                         ValueOrigin {
                             node: node_idx,
                             output_idx: output_idx as u32,
                         },
-                        phi_id,
+                        slot_id,
                     );
                 }
-                self.label_phi_nodes.insert(*id, phi_value_ids);
+                self.label_slots.insert(*id, slots);
             }
         }
-        Ok(())
-    }
 
-    /// Pass 2: Generate MIR instructions from DAG nodes
-    pub(super) fn generate_instructions_from_dag(
-        &mut self,
-        dag: &BlocklessDag,
-        module: &BlocklessDagModule,
-    ) -> Result<(), DagToMirError> {
+        // Second pass: generate instructions and register label outputs
         for (node_idx, node) in dag.nodes.iter().enumerate() {
             match &node.operation {
                 Operation::Inputs => {}
 
                 Operation::WASMOp(wasm_op) => {
-                    // Convert WASM operation to MIR instruction
-                    let mir_value = self.convert_wasm_op_to_mir(node_idx, wasm_op, node, module)?;
-                    if let Some(mir_value) = mir_value {
+                    // Convert WASM operation to CASM instruction
+                    let casm_value =
+                        self.convert_wasm_op_to_casm(node_idx, wasm_op, node, module)?;
+
+                    if let Some(mir_value) = casm_value {
                         self.insert_value(
                             ValueOrigin {
                                 node: node_idx,
@@ -64,67 +72,139 @@ impl DagToMirContext {
                 }
 
                 Operation::Label { id } => {
-                    let block_id = self.label_map.get(id).copied().ok_or_else(|| {
-                        DagToMirError::InvalidControlFlow {
-                            function_name: self.mir_function.name.clone(),
-                            reason: format!("Label {:?} not found", id),
-                            operation_context: "resolving label".to_string(),
+                    // Emit label (outputs were already registered in first pass)
+                    let label_name = self.label_names.get(id).cloned().ok_or_else(|| {
+                        DagToCasmError::InvalidControlFlow {
+                            function_name: self.casm_builder.layout.name.clone(),
+                            reason: format!("Label {} not pre-registered", id),
+                            operation_context: "emitting label".to_string(),
                         }
                     })?;
-                    self.set_current_block(block_id);
+                    self.casm_builder.emit_add_label(Label {
+                        name: label_name,
+                        address: None,
+                    });
                 }
 
                 Operation::Br(target) => {
-                    // This is either a jump or a return
-                    let target_block = self.resolve_break_target(node_idx, node, target)?;
-                    // Edge copies
-                    self.record_edge_values(node, target)?;
-
-                    let terminator = Terminator::jump(target_block);
-                    self.get_current_block()?.set_terminator(terminator);
-                    self.set_current_block(target_block);
+                    let branch_values = self.get_branch_values(node)?;
+
+                    let resolved_target = self.resolve_break_target(node_idx, node, target)?;
+
+                    match resolved_target {
+                        SolvedBreakTarget::Label(label) => {
+                            self.store_to_label_slots(target, &branch_values)?;
+                            self.casm_builder.jump(label.as_str());
+                        }
+                        SolvedBreakTarget::Return(return_values) => {
+                            self.casm_builder.return_values(
+                                &return_values,
+                                &return_values
+                                    .iter()
+                                    .map(|_| MirType::U32)
+                                    .collect::<Vec<_>>(),
+                            )?;
+                        }
+                    }
                 }
 
                 Operation::BrIf(target) => {
                     // Conditional branch - in our DAG, the condition is the last input
+                    // BrIf takes the branch when condition is NON-ZERO
                     let cond_idx = node.inputs.len().checked_sub(1).ok_or_else(|| {
-                        DagToMirError::InvalidControlFlow {
-                            function_name: self.mir_function.name.clone(),
+                        DagToCasmError::InvalidControlFlow {
+                            function_name: self.casm_builder.layout.name.clone(),
                             reason: "BrIf without condition input".to_string(),
                             operation_context: "resolving BrIf condition".to_string(),
                         }
                     })?;
                     let condition_value = self.get_input_value(&node.inputs[cond_idx])?;
-                    let target_block = self.resolve_break_target(node_idx, node, target)?;
-                    let else_block = self.mir_function.add_basic_block();
 
-                    // Edge copies on the taken edge
-                    self.record_edge_values(node, target)?;
+                    let branch_values = self.get_branch_values(node)?;
 
-                    let terminator = Terminator::branch(condition_value, target_block, else_block);
-                    self.get_current_block()?.set_terminator(terminator);
-                    self.set_current_block(else_block);
+                    let resolved_target = self.resolve_break_target(node_idx, node, target)?;
+
+                    match resolved_target {
+                        SolvedBreakTarget::Label(label) => {
+                            let taken_label = self.casm_builder.emit_new_label_name(".br_taken");
+
+                            self.casm_builder
+                                .jnz(condition_value, taken_label.as_str())?;
+
+                            // Fallthrough path: continue execution
+                            let fallthrough_label =
+                                self.casm_builder.emit_new_label_name(".br_fallthrough");
+                            self.casm_builder.jump(fallthrough_label.as_str());
+
+                            // Taken path: store values and jump to target
+                            self.casm_builder.emit_add_label(Label {
+                                name: taken_label,
+                                address: None,
+                            });
+                            self.store_to_label_slots(target, &branch_values)?;
+                            self.casm_builder.jump(label.as_str());
+
+                            // Fallthrough continues here
+                            self.casm_builder.emit_add_label(Label {
+                                name: fallthrough_label,
+                                address: None,
+                            });
+                        }
+                        SolvedBreakTarget::Return(_return_values) => {
+                            // These seem to never be generated by WOMIR
+                            Err(DagToCasmError::InvalidControlFlow {
+                                function_name: self.casm_builder.layout.name.clone(),
+                                reason: "Conditional return not yet implemented".to_string(),
+                                operation_context: "resolving BrIf return".to_string(),
+                            })?;
+                        }
+                    }
                 }
 
                 Operation::BrIfZero(target) => {
                     // Inverted conditional branch - condition is the last input
+                    // BrIfZero takes the branch when condition is ZERO
                     let cond_idx = node.inputs.len().checked_sub(1).ok_or_else(|| {
-                        DagToMirError::InvalidControlFlow {
-                            function_name: self.mir_function.name.clone(),
+                        DagToCasmError::InvalidControlFlow {
+                            function_name: self.casm_builder.layout.name.clone(),
                             reason: "BrIfZero without condition input".to_string(),
                             operation_context: "resolving BrIfZero condition".to_string(),
                         }
                     })?;
                     let condition_value = self.get_input_value(&node.inputs[cond_idx])?;
-                    let else_target = self.resolve_break_target(node_idx, node, target)?;
-                    let then_target = self.mir_function.add_basic_block();
 
-                    // Edge copies on the taken edge
-                    self.record_edge_values(node, target)?;
+                    let branch_values = self.get_branch_values(node)?;
 
-                    let terminator = Terminator::branch(condition_value, then_target, else_target);
-                    self.get_current_block()?.set_terminator(terminator);
-                    self.set_current_block(then_target);
+                    let resolved_target = self.resolve_break_target(node_idx, node, target)?;
+
+                    match resolved_target {
+                        SolvedBreakTarget::Label(label) => {
+                            let fallthrough_label =
+                                self.casm_builder.emit_new_label_name(".fallthrough");
+
+                            // If condition is non-zero, skip the branch (jump to fallthrough)
+                            self.casm_builder
+                                .jnz(condition_value, fallthrough_label.as_str())?;
+
+                            // Taken path (when zero): store values and jump to target
+                            self.store_to_label_slots(target, &branch_values)?;
+                            self.casm_builder.jump(label.as_str());
+
+                            // Fallthrough path continues here
+                            self.casm_builder.emit_add_label(Label {
+                                name: fallthrough_label,
+                                address: None,
+                            });
+                        }
+                        SolvedBreakTarget::Return(_return_values) => {
+                            // These seem to never be generated by WOMIR
+                            Err(DagToCasmError::InvalidControlFlow {
+                                function_name: self.casm_builder.layout.name.clone(),
+                                reason: "Conditional return not yet implemented".to_string(),
+                                operation_context: "resolving BrIfZero return".to_string(),
+                            })?;
+                        }
+                    }
                 }
 
                 Operation::BrTable { targets: _ } => {
@@ -135,10 +215,6 @@ impl DagToMirContext {
                     sub_dag,
                     break_targets: _,
                 } => {
-                    // Build a normal loop (header/body/exit) from the sub-DAG
-                    // Create header block and allocate phi nodes for loop-carried values
-                    let header_block = self.mir_function.add_basic_block();
-
                     // Get loop input types from the sub-DAG's Inputs node
                     let sub_inputs_idx = 0;
                     let input_node = &sub_dag.nodes[sub_inputs_idx];
@@ -147,73 +223,62 @@ impl DagToMirContext {
                         "Loop sub-DAG must start with Inputs node"
                     );
 
-                    // Create phi nodes in the header for loop-carried values
+                    // Create stack slots for loop-carried values
                     let header_mir_types = input_node
                         .output_types
                         .iter()
-                        .map(|t| wasm_type_to_mir_type(t, &self.mir_function.name, "loop input"))
+                        .map(|t| {
+                            wasm_type_to_mir_type(t, &self.casm_builder.layout.name, "loop input")
+                        })
                         .collect::<Result<Vec<_>, _>>()?;
-                    let header_phi_nodes = self.create_phi_nodes(header_block, &header_mir_types);
-
-                    // Record initial phi operands from loop entry
-                    let current_block = self.current_block_id.unwrap();
-                    for (input_idx, input) in node.inputs.iter().enumerate() {
-                        if let Some(&phi_value_id) = header_phi_nodes.get(input_idx) {
-                            let source_value_id = self.get_value(input).ok_or_else(|| {
-                                let available_count =
-                                    self.value_maps.iter().map(|map| map.len()).sum::<usize>();
-                                DagToMirError::ValueMappingError {
-                                    function_name: self.mir_function.name.clone(),
-                                    node_idx: input.node,
-                                    reason: format!(
-                                        "Loop input {} (node {}, output {}) not found in value map",
-                                        input_idx, input.node, input.output_idx
-                                    ),
-                                    available_count,
-                                }
-                            })?;
-                            self.add_deferred_phi_operand(
-                                header_block,
-                                phi_value_id,
-                                current_block,
-                                Value::operand(source_value_id),
-                            );
-                        }
-                    }
 
-                    let terminator = Terminator::jump(header_block);
-                    self.get_current_block()?.set_terminator(terminator);
-                    self.set_current_block(header_block);
+                    let header_slots: Vec<ValueId> = header_mir_types
+                        .iter()
+                        .map(|t| self.new_typed_value_id(t.clone()))
+                        .collect();
+
+                    // Store initial values (from outer scope) into the loop slots
+                    let initial_values = self.get_branch_values(node)?;
+                    for (slot, value) in header_slots.iter().zip(initial_values.iter()) {
+                        let mir_type = self.value_types.get(slot).ok_or_else(|| {
+                            DagToCasmError::InvalidControlFlow {
+                                function_name: self.casm_builder.layout.name.clone(),
+                                reason: format!("Type not found for slot {:?}", slot),
+                                operation_context: "loop initialization".to_string(),
+                            }
+                        })?;
+                        self.casm_builder.assign(*slot, *value, mir_type, None)?;
+                    }
 
-                    // Allocate a new block for the loop body
-                    let body_block = self.mir_function.add_basic_block();
-                    let terminator = Terminator::jump(body_block);
-                    self.get_current_block()?.set_terminator(terminator);
-                    self.set_current_block(body_block);
+                    // Create header label - this is where continues jump to
+                    let header_label = self.casm_builder.emit_new_label_name(".loop_header");
+                    self.casm_builder.emit_add_label(Label {
+                        name: header_label.clone(),
+                        address: None,
+                    });
 
                     self.loop_stack.push(ActiveLoop {
-                        header_block,
-                        header_phi_nodes: header_phi_nodes.clone(),
+                        header_label: header_label.clone(),
+                        header_slots: header_slots.clone(),
                     });
 
                     // Enter a new value scope for the loop body to avoid ValueOrigin collisions
                     self.push_scope();
 
-                    // Map the sub-DAG's Inputs node (node 0) to header phi nodes
-                    for (output_idx, phi_value_id) in header_phi_nodes.iter().enumerate() {
+                    // Map the sub-DAG's Inputs node (node 0) to load from header slots
+                    for (output_idx, slot_id) in header_slots.iter().enumerate() {
                         self.insert_value(
                             ValueOrigin {
                                 node: 0,
                                 output_idx: output_idx as u32,
                             },
-                            *phi_value_id,
+                            *slot_id,
                         );
                     }
 
-                    // Pre-allocate labels inside the loop sub-DAG
-                    self.allocate_blocks_and_phi_nodes(sub_dag)?;
                     // Lower the body
                     self.generate_instructions_from_dag(sub_dag, module)?;
+
                     // Exit the loop body's value scope
                     self.pop_scope();
 
@@ -226,15 +291,75 @@ impl DagToMirContext {
         Ok(())
     }
 
-    /// Helper: record phi operands for the taken edge of a branch based on BreakTarget kind
-    pub(super) fn record_edge_values(
+    /// Store branch values to the appropriate stack slots before jumping
+    pub(super) fn store_to_label_slots(
         &mut self,
-        node: &Node,
         target: &BreakTarget,
-    ) -> Result<(), DagToMirError> {
+        branch_values: &[Value],
+    ) -> Result<(), DagToCasmError> {
+        if branch_values.is_empty() {
+            return Ok(());
+        }
+
         match &target.kind {
-            TargetType::Label(label_id) => self.record_branch_values_for_label(node, *label_id),
-            TargetType::FunctionOrLoop => self.record_branch_values_for_loop(node, target.depth),
+            TargetType::Label(label_id) => {
+                // Get slots that were pre-allocated in first pass
+                let slots = self
+                    .label_slots
+                    .get(label_id)
+                    .ok_or_else(|| DagToCasmError::InvalidControlFlow {
+                        function_name: self.casm_builder.layout.name.clone(),
+                        reason: format!(
+                            "Label {} has no allocated slots but {} values need to be stored",
+                            self.label_names
+                                .get(label_id)
+                                .map(|s| s.as_str())
+                                .unwrap_or("?"),
+                            branch_values.len()
+                        ),
+                        operation_context: "storing to label slots".to_string(),
+                    })?
+                    .clone();
+
+                // Store each value to its corresponding slot
+                for (i, (slot, value)) in slots.iter().zip(branch_values.iter()).enumerate() {
+                    let mir_type = self.value_types.get(slot).ok_or_else(|| {
+                        DagToCasmError::InvalidControlFlow {
+                            function_name: self.casm_builder.layout.name.clone(),
+                            reason: format!("Type not found for slot {:?} at index {}", slot, i),
+                            operation_context: "storing to label slots".to_string(),
+                        }
+                    })?;
+                    self.casm_builder.assign(*slot, *value, mir_type, None)?;
+                }
+                Ok(())
+            }
+            TargetType::FunctionOrLoop => {
+                // Store to loop header slots
+                let d = target.depth as usize;
+                if !self.loop_stack.is_empty() && d < self.loop_stack.len() {
+                    let idx = self.loop_stack.len() - 1 - d;
+                    let header_slots = self.loop_stack[idx].header_slots.clone();
+
+                    // Store each value to its corresponding loop slot
+                    for (i, (slot, value)) in
+                        header_slots.iter().zip(branch_values.iter()).enumerate()
+                    {
+                        let mir_type = self.value_types.get(slot).ok_or_else(|| {
+                            DagToCasmError::InvalidControlFlow {
+                                function_name: self.casm_builder.layout.name.clone(),
+                                reason: format!(
+                                    "Type not found for loop slot {:?} at index {}",
+                                    slot, i
+                                ),
+                                operation_context: "storing to loop slots".to_string(),
+                            }
+                        })?;
+                        self.casm_builder.assign(*slot, *value, mir_type, None)?;
+                    }
+                }
+                Ok(())
+            }
         }
     }
 
@@ -244,19 +369,19 @@ impl DagToMirContext {
         node_idx: usize,
         node: &Node,
         target: &BreakTarget,
-    ) -> Result<cairo_m_compiler_mir::BasicBlockId, DagToMirError> {
+    ) -> Result<SolvedBreakTarget, DagToCasmError> {
         match (&target.kind, target.depth) {
             (TargetType::Label(label_id), _depth) => {
                 // Direct jump to a label at current scope
-                self.label_map.get(label_id).map_or_else(
+                self.label_names.get(label_id).map_or_else(
                     || {
-                        Err(DagToMirError::InvalidControlFlow {
-                            function_name: self.mir_function.name.clone(),
+                        Err(DagToCasmError::InvalidControlFlow {
+                            function_name: self.casm_builder.layout.name.clone(),
                             reason: format!("Label {} not found in label_map", label_id),
                             operation_context: "resolving break target".to_string(),
                         })
                     },
-                    |block_id| Ok(*block_id),
+                    |label| Ok(SolvedBreakTarget::Label(label.clone())),
                 )
             }
 
@@ -267,34 +392,29 @@ impl DagToMirContext {
                 if !self.loop_stack.is_empty() && d < self.loop_stack.len() {
                     let idx = self.loop_stack.len() - 1 - d;
                     let loop_info = &self.loop_stack[idx];
-                    Ok(loop_info.header_block)
+                    Ok(SolvedBreakTarget::Label(loop_info.header_label.clone()))
                 } else if d >= self.loop_stack.len() && !self.loop_stack.is_empty() {
-                    return Err(DagToMirError::LoopDepthError {
-                        function_name: self.mir_function.name.clone(),
+                    return Err(DagToCasmError::LoopDepthError {
+                        function_name: self.casm_builder.layout.name.clone(),
                         node_idx,
                         requested_depth: depth,
                         available_depth: self.loop_stack.len(),
                     });
                 } else {
-                    // No active loop at this depth: treat as function return
-                    let return_block = self.mir_function.add_basic_block();
-
                     let return_values: Vec<Value> = node
                         .inputs
                         .iter()
                         .map(|input| self.get_input_value(input))
                         .collect::<Result<_, _>>()?;
 
-                    let terminator = Terminator::return_values(return_values);
-                    self.block_mut(return_block)?.set_terminator(terminator);
-                    Ok(return_block)
+                    Ok(SolvedBreakTarget::Return(return_values))
                 }
             }
         }
     }
 
     /// Extract branch values from a node, excluding conditional inputs
-    pub(super) fn get_branch_values(&self, node: &Node) -> Result<Vec<Value>, DagToMirError> {
+    pub(super) fn get_branch_values(&self, node: &Node) -> Result<Vec<Value>, DagToCasmError> {
         // Determine which inputs represent data (exclude condition for conditional branches)
         // For BrIf / BrIfZero, the last input is the condition; exclude it from data copies
         let data_inputs_start_index = 0;
@@ -308,91 +428,4 @@ impl DagToMirContext {
             .map(|input| self.get_input_value(input))
             .collect()
     }
-
-    /// Record branch values as phi operands for a label when branching to it
-    pub(super) fn record_branch_values_for_label(
-        &mut self,
-        node: &Node,
-        label_id: u32,
-    ) -> Result<(), DagToMirError> {
-        let branch_values = self.get_branch_values(node)?;
-        let current_block =
-            self.current_block_id
-                .ok_or_else(|| DagToMirError::InvalidControlFlow {
-                    function_name: self.mir_function.name.clone(),
-                    reason: "No current block when recording phi operands".to_string(),
-                    operation_context: "recording branch values for label".to_string(),
-                })?;
-
-        let phi_value_ids = self
-            .label_phi_nodes
-            .get(&label_id)
-            .cloned()
-            .ok_or_else(|| DagToMirError::InvalidControlFlow {
-                function_name: self.mir_function.name.clone(),
-                reason: format!("No phi nodes allocated for label {}", label_id),
-                operation_context: "recording branch values for label".to_string(),
-            })?;
-
-        let target_block = self.label_map.get(&label_id).copied().ok_or_else(|| {
-            DagToMirError::InvalidControlFlow {
-                function_name: self.mir_function.name.clone(),
-                reason: format!("Label {} not found in label_map", label_id),
-                operation_context: "recording branch values for label".to_string(),
-            }
-        })?;
-
-        // Record phi operands for each value
-        let count = core::cmp::min(branch_values.len(), phi_value_ids.len());
-        for i in 0..count {
-            self.add_deferred_phi_operand(
-                target_block,
-                phi_value_ids[i],
-                current_block,
-                branch_values[i],
-            );
-        }
-
-        Ok(())
-    }
-
-    /// Record branch values as phi operands for loop header when continuing to a loop
-    pub(super) fn record_branch_values_for_loop(
-        &mut self,
-        node: &Node,
-        depth: u32,
-    ) -> Result<(), DagToMirError> {
-        // Compute target loop based on depth
-        let d = depth as usize;
-        if self.loop_stack.is_empty() || d >= self.loop_stack.len() {
-            return Ok(()); // Treat as return; phi operands handled by return elsewhere
-        }
-        let idx = self.loop_stack.len() - 1 - d;
-        let loop_info = &self.loop_stack[idx];
-        let header_phi_nodes = loop_info.header_phi_nodes.clone();
-        let header_block = loop_info.header_block;
-
-        let current_block =
-            self.current_block_id
-                .ok_or_else(|| DagToMirError::InvalidControlFlow {
-                    function_name: self.mir_function.name.clone(),
-                    reason: "No current block when recording phi operands".to_string(),
-                    operation_context: "recording branch values for loop".to_string(),
-                })?;
-
-        let branch_values = self.get_branch_values(node)?;
-
-        // Record phi operands for each loop-carried value
-        let count = core::cmp::min(branch_values.len(), header_phi_nodes.len());
-        for i in 0..count {
-            self.add_deferred_phi_operand(
-                header_block,
-                header_phi_nodes[i],
-                current_block,
-                branch_values[i],
-            );
-        }
-
-        Ok(())
-    }
 }
diff --git a/crates/wasm/src/lowering/context.rs b/crates/wasm/src/lowering/context.rs
index 9e418919..396279b5 100644
--- a/crates/wasm/src/lowering/context.rs
+++ b/crates/wasm/src/lowering/context.rs
@@ -1,75 +1,56 @@
-use super::DagToMirError;
-use cairo_m_compiler_mir::{
-    instruction::Instruction, instruction::InstructionKind, BasicBlock, BasicBlockId, MirFunction,
-    MirType, Value, ValueId,
-};
+use super::DagToCasmError;
+use cairo_m_compiler_codegen::{CasmBuilder, FunctionLayout};
+use cairo_m_compiler_mir::{MirType, Value, ValueId};
 use std::collections::HashMap;
 use womir::loader::dag::ValueOrigin;
 
-/// Context for converting a single function DAG to MIR
-pub struct DagToMirContext {
-    pub(crate) mir_function: MirFunction,
-    pub(crate) value_maps: Vec<HashMap<ValueOrigin, ValueId>>,
-    pub(crate) label_map: HashMap<u32, BasicBlockId>,
-    pub(crate) current_block_id: Option<BasicBlockId>,
-    pub(crate) current_source_block: Option<BasicBlockId>,
-    pub(crate) label_phi_nodes: HashMap<u32, Vec<ValueId>>,
+/// Context for converting a single function DAG to CASM
+pub struct DagToCasmContext {
+    pub(crate) casm_builder: CasmBuilder,
+    /// Maps label IDs to their allocated stack slots for incoming values
+    pub(crate) label_names: HashMap<u32, String>,
+    pub(crate) label_slots: HashMap<u32, Vec<ValueId>>,
     pub(crate) loop_stack: Vec<ActiveLoop>,
-    pub(crate) deferred_phi_operands: Vec<(BasicBlockId, ValueId, BasicBlockId, Value)>,
+    pub(crate) next_value_id: usize,
+    pub(crate) value_types: HashMap<ValueId, MirType>,
+    pub(crate) value_maps: Vec<HashMap<ValueOrigin, ValueId>>,
 }
 
 /// Information about an active loop during lowering
 pub struct ActiveLoop {
-    pub(crate) header_block: BasicBlockId,
-    pub(crate) header_phi_nodes: Vec<ValueId>,
+    pub(crate) header_label: String,
+    /// Stack slots allocated for loop-carried values
+    pub(crate) header_slots: Vec<ValueId>,
 }
 
-impl DagToMirContext {
-    pub(crate) fn new(func_name: String) -> Self {
-        let mir_function = MirFunction::new(func_name);
-
+impl DagToCasmContext {
+    pub(crate) fn new(func_layout: FunctionLayout, label_counter: usize) -> Self {
         Self {
-            value_maps: vec![HashMap::new()],
-            label_map: HashMap::new(),
-            current_source_block: None,
-            label_phi_nodes: HashMap::new(),
-
-            mir_function,
-            current_block_id: Some(0.into()),
+            casm_builder: CasmBuilder::new(func_layout, label_counter),
+            label_names: HashMap::new(),
+            label_slots: HashMap::new(),
             loop_stack: Vec::new(),
-            deferred_phi_operands: Vec::new(),
+            next_value_id: 0,
+            value_types: HashMap::new(),
+            value_maps: vec![HashMap::new()], // Initialize with one scope for function-level values
         }
     }
 
-    pub(crate) fn get_current_block(&mut self) -> Result<&mut BasicBlock, DagToMirError> {
-        let block_id = self
-            .current_block_id
-            .ok_or_else(|| DagToMirError::InvalidControlFlow {
-                function_name: self.mir_function.name.clone(),
-                reason: "No current block set - invalid state".to_string(),
-                operation_context: "attempting to get current block".to_string(),
-            })?;
-
-        self.block_mut(block_id)
-    }
-
-    pub(crate) const fn set_current_block(&mut self, block_id: BasicBlockId) {
-        self.current_source_block = self.current_block_id;
-        self.current_block_id = Some(block_id);
+    /// Generates a new unique value ID with type information
+    pub fn new_typed_value_id(&mut self, mir_type: MirType) -> ValueId {
+        self.next_value_id += 1;
+        let id = ValueId::new(self.next_value_id);
+        self.value_types.insert(id, mir_type);
+        let _ = self.casm_builder.layout.allocate_local(id, 2);
+        id
     }
 
-    pub(crate) fn block_mut(
-        &mut self,
-        block_id: BasicBlockId,
-    ) -> Result<&mut BasicBlock, DagToMirError> {
-        self.mir_function
-            .basic_blocks
-            .get_mut(block_id)
-            .ok_or_else(|| DagToMirError::InvalidControlFlow {
-                function_name: self.mir_function.name.clone(),
-                reason: format!("Block {:?} does not exist", block_id),
-                operation_context: "attempting to access basic block".to_string(),
-            })
+    /// Generates a new unique value ID with type information, without allocating
+    pub fn new_value_id_for_type(&mut self, mir_type: MirType) -> ValueId {
+        self.next_value_id += 1;
+        let id = ValueId::new(self.next_value_id);
+        self.value_types.insert(id, mir_type);
+        id
     }
 
     pub(crate) fn insert_value(&mut self, origin: ValueOrigin, value_id: ValueId) {
@@ -90,79 +71,21 @@ impl DagToMirContext {
     pub(crate) fn push_scope(&mut self) {
         self.value_maps.push(HashMap::new());
     }
+
     pub(crate) fn pop_scope(&mut self) {
         self.value_maps.pop();
     }
 
-    /// Add a deferred phi operand to be processed later
-    pub(crate) fn add_deferred_phi_operand(
-        &mut self,
-        dest_block: BasicBlockId,
-        dest_value: ValueId,
-        source_block: BasicBlockId,
-        source_value: Value,
-    ) {
-        self.deferred_phi_operands
-            .push((dest_block, dest_value, source_block, source_value));
-    }
-
-    /// Finalize all phi nodes by adding their operands
-    pub(crate) fn finalize_phi_nodes(&mut self) -> Result<(), DagToMirError> {
-        // Group deferred operands by (block_id, dest_value_id)
-        let mut phi_operands: HashMap<(BasicBlockId, ValueId), Vec<(BasicBlockId, Value)>> =
-            HashMap::new();
-
-        for (dest_block, dest_value, source_block, source_value) in &self.deferred_phi_operands {
-            phi_operands
-                .entry((*dest_block, *dest_value))
-                .or_default()
-                .push((*source_block, *source_value));
-        }
-
-        // Update phi instructions with their operands
-        for ((block_id, dest_value_id), operands) in phi_operands {
-            let function_name = self.mir_function.name.clone();
-            let block =
-                self.block_mut(block_id)
-                    .map_err(|_| DagToMirError::InvalidControlFlow {
-                        function_name: function_name.clone(),
-                        reason: format!("Block {:?} not found when finalizing phi nodes", block_id),
-                        operation_context: "finalizing phi nodes".to_string(),
-                    })?;
-
-            // Find the phi instruction with this destination
-            for instruction in block.phi_instructions_mut() {
-                // Get the destination value id before borrowing mutably
-                let phi_dest = if let InstructionKind::Phi { dest, .. } = &instruction.kind {
-                    Some(*dest)
-                } else {
-                    None
-                };
-
-                if let Some(dest) = phi_dest {
-                    if dest == dest_value_id {
-                        if let Some(phi_operands_mut) = instruction.phi_operands_mut() {
-                            *phi_operands_mut = operands.clone();
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-
     /// Get MIR value for a WASM ValueOrigin
     pub(crate) fn get_input_value(
         &self,
         value_origin: &ValueOrigin,
-    ) -> Result<Value, DagToMirError> {
+    ) -> Result<Value, DagToCasmError> {
         self.get_value(value_origin).map_or_else(
             || {
                 let available_count = self.value_maps.iter().map(|map| map.len()).sum::<usize>();
-                Err(DagToMirError::ValueMappingError {
-                    function_name: self.mir_function.name.clone(),
+                Err(DagToCasmError::ValueMappingError {
+                    function_name: self.casm_builder.layout.name.clone(),
                     node_idx: value_origin.node,
                     reason: format!(
                         "Value not found: node {}, output {}",
@@ -174,24 +97,4 @@ impl DagToMirContext {
             |value_id| Ok(Value::operand(value_id)),
         )
     }
-
-    /// Utility: create empty phi nodes for a list of MIR types in a block, returning their ValueIds
-    pub(crate) fn create_phi_nodes(
-        &mut self,
-        block: BasicBlockId,
-        types: &[MirType],
-    ) -> Vec<ValueId> {
-        let mut ids = Vec::with_capacity(types.len());
-        for ty in types {
-            let id = self.mir_function.new_typed_value_id(ty.clone());
-            let phi = Instruction::empty_phi(id, ty.clone());
-            // Safe: block allocated by caller
-            self.mir_function
-                .get_basic_block_mut(block)
-                .unwrap()
-                .push_phi_front(phi);
-            ids.push(id);
-        }
-        ids
-    }
 }
diff --git a/crates/wasm/src/lowering/mod.rs b/crates/wasm/src/lowering/mod.rs
index d4fd83ef..3f5fa98f 100644
--- a/crates/wasm/src/lowering/mod.rs
+++ b/crates/wasm/src/lowering/mod.rs
@@ -3,16 +3,20 @@ mod cfg;
 mod context;
 mod ops;
 
+use std::collections::HashMap;
+
 use crate::loader::{BlocklessDagModule, WasmLoadError};
-use cairo_m_compiler_mir::{MirFunction, MirModule, MirType, PassManager};
+use cairo_m_common::program::{AbiSlot, AbiType};
+use cairo_m_compiler_codegen::{CasmBuilder, CodeGenerator, CodegenError, FunctionLayout};
+use cairo_m_compiler_mir::{DataLayout, MirType};
 use thiserror::Error;
 use womir::loader::dag::ValueOrigin;
 use womir::loader::FunctionProcessingStage;
 
-use context::DagToMirContext;
+use context::DagToCasmContext;
 
 #[derive(Error, Debug)]
-pub enum DagToMirError {
+pub enum DagToCasmError {
     #[error("Failed to load Wasm module: {0}")]
     WasmLoadError(#[from] WasmLoadError),
     #[error("Unsupported WASM operation {op:?} in function '{function_name}' at node {node_idx}: {suggestion}")]
@@ -48,21 +52,91 @@ pub enum DagToMirError {
         requested_depth: u32,
         available_depth: usize,
     },
+    #[error("Code generation failed: {0}")]
+    CodegenError(#[from] CodegenError),
 }
 
-/// Lower a whole WOMIR program to MIR
-pub fn lower_program_to_mir(
+pub(crate) fn get_function_name(module: &BlocklessDagModule, func_idx: u32) -> String {
+    let wasm_program = &module.0;
+    wasm_program
+        .m
+        .exported_functions
+        .get(&(func_idx))
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| format!("func_{}", func_idx))
+}
+
+pub(crate) fn get_function_parameter_types(
     module: &BlocklessDagModule,
-    mut pipeline: PassManager,
-) -> Result<MirModule, DagToMirError> {
-    let mut mir_module = MirModule::new();
-    let program = &module.0;
-    for (func_idx, _) in program.functions.iter().enumerate() {
-        let mut mir_function = function_to_mir(module, func_idx)?;
-        pipeline.run(&mut mir_function);
-        mir_module.add_function(mir_function);
+    func_idx: u32,
+) -> Result<Vec<MirType>, DagToCasmError> {
+    let wasm_program = &module.0;
+    let func_type = wasm_program.m.get_func_type(func_idx);
+    let func_name = get_function_name(module, func_idx);
+    func_type
+        .ty
+        .params()
+        .iter()
+        .map(|ty| wasm_type_to_mir_type(ty, &func_name, "function parameters"))
+        .collect::<Result<Vec<MirType>, DagToCasmError>>()
+}
+
+pub(crate) fn get_function_return_types(
+    module: &BlocklessDagModule,
+    func_idx: u32,
+) -> Result<Vec<MirType>, DagToCasmError> {
+    let wasm_program = &module.0;
+    let func_type = wasm_program.m.get_func_type(func_idx);
+    let func_name = get_function_name(module, func_idx);
+    func_type
+        .ty
+        .results()
+        .iter()
+        .map(|ty| wasm_type_to_mir_type(ty, &func_name, "function return types"))
+        .collect::<Result<Vec<MirType>, DagToCasmError>>()
+}
+
+/// Lower a whole WOMIR program to CASM CodeGenerator
+pub fn lower_program_to_casm(module: &BlocklessDagModule) -> Result<CodeGenerator, DagToCasmError> {
+    let mut codegen = CodeGenerator::new();
+    let wasm_program = &module.0;
+
+    let mut label_counter = 0;
+
+    // Process each function
+    for (func_idx, _) in wasm_program.functions.iter().enumerate() {
+        let builder = function_to_casm(module, func_idx as u32, label_counter)?;
+
+        let param_types = get_function_parameter_types(module, func_idx as u32)?;
+        let return_types = get_function_return_types(module, func_idx as u32)?;
+
+        let params = param_types
+            .iter()
+            .enumerate()
+            .map(|(i, _)| AbiSlot {
+                name: format!("param_{}", i),
+                ty: AbiType::U32,
+            })
+            .collect();
+        let returns = return_types
+            .iter()
+            .enumerate()
+            .map(|(i, _)| AbiSlot {
+                name: format!("return_{}", i),
+                ty: AbiType::U32,
+            })
+            .collect();
+
+        label_counter += builder.label_counter();
+
+        codegen.add_function_from_builder(builder, params, returns)?;
     }
-    Ok(mir_module)
+
+    codegen.calculate_memory_layout()?;
+
+    codegen.resolve_labels()?;
+
+    Ok(codegen)
 }
 
 /// Convert WASM type to MIR type (limited support for now)
@@ -70,10 +144,10 @@ fn wasm_type_to_mir_type(
     wasm_type: &wasmparser::ValType,
     function_name: &str,
     context: &str,
-) -> Result<MirType, DagToMirError> {
+) -> Result<MirType, DagToCasmError> {
     match wasm_type {
         wasmparser::ValType::I32 => Ok(MirType::U32),
-        _ => Err(DagToMirError::UnsupportedWasmType {
+        _ => Err(DagToCasmError::UnsupportedWasmType {
             wasm_type: *wasm_type,
             function_name: function_name.to_string(),
             context: context.to_string(),
@@ -82,64 +156,43 @@ fn wasm_type_to_mir_type(
 }
 
 /// Convert a single WASM function to MIR using a two-pass algorithm
-fn function_to_mir(
+fn function_to_casm(
     module: &BlocklessDagModule,
-    func_idx: usize,
-) -> Result<MirFunction, DagToMirError> {
+    func_idx: u32,
+    label_counter: usize,
+) -> Result<CasmBuilder, DagToCasmError> {
     let program = &module.0;
-    let func_name = program
-        .m
-        .exported_functions
-        .get(&(func_idx as u32))
-        .map(|s| s.to_string())
-        .unwrap_or_else(|| format!("func_{}", func_idx));
-
-    let mut context = DagToMirContext::new(func_name.clone());
+    let func_name = get_function_name(module, func_idx);
+    let param_types = get_function_parameter_types(module, func_idx)?;
+    let return_types = get_function_return_types(module, func_idx)?;
 
-    // Get function type information for parameters and return types
-    let func_type = program.m.get_func_type(func_idx as u32);
-
-    // Handle param types with proper error handling
-    let param_types: Vec<MirType> = func_type
-        .ty
-        .params()
-        .iter()
-        .map(|ty| wasm_type_to_mir_type(ty, &func_name, "function parameters"))
-        .collect::<Result<Vec<MirType>, DagToMirError>>()?;
+    // Construct layout
+    let layout = FunctionLayout {
+        name: func_name.clone(),
+        value_layouts: HashMap::default(),
+        frame_size: 0,
+        num_parameters: param_types.len(),
+        num_return_values: return_types.len(),
+        num_return_slots: return_types.iter().map(DataLayout::memory_size_of).sum(),
+    };
 
-    // Handle return types with proper error handling
-    let return_types: Vec<MirType> = func_type
-        .ty
-        .results()
-        .iter()
-        .map(|ty| wasm_type_to_mir_type(ty, &func_name, "function return types"))
-        .collect::<Result<Vec<MirType>, DagToMirError>>()?;
+    let mut context = DagToCasmContext::new(layout, label_counter);
 
-    // Allocate parameters
-    for (i, param_type) in param_types.iter().enumerate() {
-        let param_id = context.mir_function.new_typed_value_id(param_type.clone());
-        context.mir_function.parameters.push(param_id);
-        context.insert_value(
-            ValueOrigin {
-                node: 0,
-                output_idx: i as u32,
-            },
-            param_id,
-        );
-    }
+    // Allocate parameters at their proper parameter offsets
+    allocate_function_parameters(&mut context, &param_types, &return_types)?;
 
     // Get the DAG for this function
-    let dag = match program.functions.get(func_idx) {
+    let dag = match program.functions.get(func_idx as usize) {
         Some(FunctionProcessingStage::BlocklessDag(dag)) => dag,
         Some(_) => {
-            return Err(DagToMirError::InvalidControlFlow {
+            return Err(DagToCasmError::InvalidControlFlow {
                 function_name: func_name,
                 reason: "Function not at BlocklessDag stage".to_string(),
                 operation_context: "lowering function".to_string(),
             });
         }
         None => {
-            return Err(DagToMirError::ValueMappingError {
+            return Err(DagToCasmError::ValueMappingError {
                 function_name: func_name,
                 node_idx: 0,
                 reason: format!("Function {} not found", func_idx),
@@ -148,34 +201,66 @@ fn function_to_mir(
         }
     };
 
-    // Preallocate CFG structures and lower body
-    context.allocate_blocks_and_phi_nodes(dag)?;
     context.generate_instructions_from_dag(dag, module)?;
 
-    // Finalize all phi nodes with their operands
-    context.finalize_phi_nodes()?;
+    Ok(context.casm_builder)
+}
 
-    // Set entry block if we created any blocks
-    if !context.mir_function.basic_blocks.is_empty() {
-        context.mir_function.entry_block = 0.into();
-    }
+/// Allocates function parameters at their proper negative FP offsets
+///
+/// Parameters are stored at negative offsets relative to the frame pointer,
+/// following the Cairo-M calling convention layout:
+/// fp - M - K - CALLER_SAVE_SLOTS + cumulative_param_size
+fn allocate_function_parameters(
+    context: &mut DagToCasmContext,
+    param_types: &[MirType],
+    return_types: &[MirType],
+) -> Result<(), DagToCasmError> {
+    // This is very similar to FunctionLayout::allocate_parameters_with_sizes()
+    // TODO : refactor FunctionLayout ABI to fix this
+    use cairo_m_compiler_codegen::layout::ValueLayout;
+
+    // Calculate total parameter and return slots for proper offset calculation
+    let m_slots: usize = param_types.iter().map(DataLayout::memory_size_of).sum();
+    let k_slots: usize = return_types.iter().map(DataLayout::memory_size_of).sum();
+    const CALLER_SAVE_SLOTS: i32 = 2;
+
+    // Allocate parameters at their proper parameter offsets
+    let mut cumulative_param_size = 0;
+    for (i, param_type) in param_types.iter().enumerate() {
+        let param_id = context.new_value_id_for_type(param_type.clone());
+        let size = DataLayout::memory_size_of(param_type);
+
+        // Calculate offset using the frame layout formula:
+        // fp - M - K - CALLER_SAVE_SLOTS + cumulative_param_size
+        let offset =
+            -(m_slots as i32) - (k_slots as i32) - CALLER_SAVE_SLOTS + cumulative_param_size as i32;
 
-    // Populate parameter types
-    for (i, &param_value_id) in context.mir_function.parameters.iter().enumerate() {
-        if let Some(param_type) = param_types.get(i) {
+        // Manually insert the parameter layout
+        if size == 1 {
             context
-                .mir_function
-                .value_types
-                .insert(param_value_id, param_type.clone());
+                .casm_builder
+                .layout
+                .value_layouts
+                .insert(param_id, ValueLayout::Slot { offset });
+        } else {
+            context
+                .casm_builder
+                .layout
+                .value_layouts
+                .insert(param_id, ValueLayout::MultiSlot { offset, size });
         }
-    }
 
-    // Define return values from the function signature (types/arity only).
-    // The actual values returned are supplied by each Return terminator.
-    context.mir_function.return_values = return_types
-        .iter()
-        .map(|ty| context.mir_function.new_typed_value_id(ty.clone()))
-        .collect();
+        context.insert_value(
+            ValueOrigin {
+                node: 0,
+                output_idx: i as u32,
+            },
+            param_id,
+        );
+
+        cumulative_param_size += size;
+    }
 
-    Ok(context.mir_function)
+    Ok(())
 }
diff --git a/crates/wasm/src/lowering/ops.rs b/crates/wasm/src/lowering/ops.rs
index 96d0132c..681d2add 100644
--- a/crates/wasm/src/lowering/ops.rs
+++ b/crates/wasm/src/lowering/ops.rs
@@ -1,21 +1,22 @@
-use super::{wasm_type_to_mir_type, DagToMirContext, DagToMirError};
+use super::{
+    get_function_name, get_function_parameter_types, get_function_return_types, DagToCasmContext,
+    DagToCasmError,
+};
 use crate::loader::BlocklessDagModule;
 use cairo_m_compiler_mir::instruction::CalleeSignature;
-use cairo_m_compiler_mir::{
-    instruction::Instruction, BinaryOp, FunctionId, MirType, Place, Value, ValueId,
-};
+use cairo_m_compiler_mir::{BinaryOp, MirType, Value, ValueId};
 use cairo_m_runner::memory::MAX_ADDRESS;
 use wasmparser::Operator as Op;
 use womir::loader::blockless_dag::Node;
 
-impl DagToMirContext {
-    /// Convert a WASM binary opcode to a MIR binary opcode
+impl DagToCasmContext {
+    /// Convert a WASM binary opcode to a casm binary opcode
     /// TODO : bit shifts, rotations, u8 operations, etc.
     pub(super) fn wasm_binary_opcode_to_mir(
         &self,
         wasm_op: &Op,
         node_idx: usize,
-    ) -> Result<BinaryOp, DagToMirError> {
+    ) -> Result<BinaryOp, DagToCasmError> {
         match wasm_op {
             Op::I32Add => Ok(BinaryOp::U32Add),
             Op::I32Sub => Ok(BinaryOp::U32Sub),
@@ -30,27 +31,27 @@ impl DagToMirContext {
             Op::I32And => Ok(BinaryOp::U32BitwiseAnd),
             Op::I32Or => Ok(BinaryOp::U32BitwiseOr),
             Op::I32Xor => Ok(BinaryOp::U32BitwiseXor),
-            _ => Err(DagToMirError::UnsupportedOperation {
+            _ => Err(DagToCasmError::UnsupportedOperation {
                 op: format!("{:?}", wasm_op),
-                function_name: self.mir_function.name.clone(),
+                function_name: self.casm_builder.layout.name.clone(),
                 node_idx,
                 suggestion: "".to_string(),
             }),
         }
     }
 
-    pub(super) fn convert_wasm_binop_to_mir(
+    pub(super) fn convert_wasm_binop_to_casm(
         &mut self,
         node_idx: usize,
         wasm_op: &Op,
         left: Value,
         right: Value,
         dest_type: MirType,
-    ) -> Result<Option<ValueId>, DagToMirError> {
-        let result_id = self.mir_function.new_typed_value_id(dest_type);
+    ) -> Result<Option<ValueId>, DagToCasmError> {
+        let result_id = self.new_typed_value_id(dest_type);
         let mir_op = self.wasm_binary_opcode_to_mir(wasm_op, node_idx)?;
-        let instruction = Instruction::binary_op(mir_op, result_id, left, right);
-        self.get_current_block()?.push_instruction(instruction);
+        self.casm_builder
+            .binary_op(mir_op, result_id, left, right, None)?;
         Ok(Some(result_id))
     }
 
@@ -61,31 +62,29 @@ impl DagToMirContext {
         &mut self,
         wasm_address: Value,
         wasm_offset: u64,
-    ) -> Result<ValueId, DagToMirError> {
+    ) -> Result<ValueId, DagToCasmError> {
         // temp1 = wasm_address / 2
-        let temp1 = self.mir_function.new_typed_value_id(MirType::U32);
-        let inst_div_by_2 =
-            Instruction::binary_op(BinaryOp::U32Div, temp1, wasm_address, Value::integer(2));
-
-        // temp2 = temp1 as felt
-        let temp2 = self.mir_function.new_typed_value_id(MirType::Felt);
-        let inst_cast =
-            Instruction::cast(temp2, Value::operand(temp1), MirType::U32, MirType::Felt);
+        let temp1 = self.new_typed_value_id(MirType::U32);
+        self.casm_builder.binary_op(
+            BinaryOp::U32Div,
+            temp1,
+            wasm_address,
+            Value::integer(2),
+            None,
+        )?;
 
-        // cm_address = heap_start + cm_offset - temp2
+        // cm_address = heap_start + cm_offset - temp1
         // without globals, heap starts at MAX_ADDRESS
-        let cm_address = self.mir_function.new_typed_value_id(MirType::Felt);
+        let cm_address = self.new_typed_value_id(MirType::Felt);
         let cm_offset = self.cm_offset_from_wasm_i32_offset(wasm_offset);
-        let inst_sub = Instruction::binary_op(
+        self.casm_builder.binary_op(
             BinaryOp::Sub,
             cm_address,
             Value::integer((MAX_ADDRESS as i32 + cm_offset) as u32),
-            Value::operand(temp2),
-        );
+            Value::operand(temp1),
+            None,
+        )?;
 
-        self.get_current_block()?.push_instruction(inst_div_by_2);
-        self.get_current_block()?.push_instruction(inst_cast);
-        self.get_current_block()?.push_instruction(inst_sub);
         Ok(cm_address)
     }
 
@@ -95,13 +94,13 @@ impl DagToMirContext {
     }
 
     /// Convert a WASM operation to MIR instructions
-    pub(super) fn convert_wasm_op_to_mir(
+    pub(super) fn convert_wasm_op_to_casm(
         &mut self,
         node_idx: usize,
         wasm_op: &Op,
         node: &Node,
         module: &BlocklessDagModule,
-    ) -> Result<Option<ValueId>, DagToMirError> {
+    ) -> Result<Option<ValueId>, DagToCasmError> {
         let inputs: Result<Vec<Value>, _> = node
             .inputs
             .iter()
@@ -117,7 +116,7 @@ impl DagToMirContext {
             | Op::I32DivU
             | Op::I32And
             | Op::I32Or
-            | Op::I32Xor => self.convert_wasm_binop_to_mir(
+            | Op::I32Xor => self.convert_wasm_binop_to_casm(
                 node_idx,
                 wasm_op,
                 inputs[0],
@@ -128,66 +127,135 @@ impl DagToMirContext {
             // For comparisons, we produce a boolean result
             // This is not WASM compliant, but works if these values are only used in conditional branches
             // TODO : cast everything correctly or sync with VM so that comparisons between u32 produce u32 booleans
-            Op::I32Eq | Op::I32Ne | Op::I32GtU | Op::I32GeU | Op::I32LtU | Op::I32LeU => self
-                .convert_wasm_binop_to_mir(node_idx, wasm_op, inputs[0], inputs[1], MirType::Bool),
+            Op::I32Eq | Op::I32LtU => self.convert_wasm_binop_to_casm(
+                node_idx,
+                wasm_op,
+                inputs[0],
+                inputs[1],
+                MirType::Bool,
+            ),
+
+            // (a > b) == (b < a)
+            Op::I32GtU => self.convert_wasm_binop_to_casm(
+                node_idx,
+                &Op::I32LtU,
+                inputs[1],
+                inputs[0],
+                MirType::Bool,
+            ),
+
+            // a != b == 1 - (a == b)
+            // TODO : peephole optimization to swap conditional branches instead if possible
+            Op::I32Ne => {
+                let result_id = self.new_typed_value_id(MirType::Bool);
+                let temp = self.new_typed_value_id(MirType::Bool);
+                self.casm_builder
+                    .binary_op(BinaryOp::U32Eq, temp, inputs[0], inputs[1], None)?;
+                self.casm_builder.binary_op(
+                    BinaryOp::Sub,
+                    result_id,
+                    Value::integer(1),
+                    Value::operand(temp),
+                    None,
+                )?;
+                Ok(Some(result_id))
+            }
+
+            // (a <= b) == !(b < a)
+            // (a >= b) == !(a < b)
+            Op::I32LeU | Op::I32GeU => {
+                let temp = self.new_typed_value_id(MirType::Bool);
+                let result_id = self.new_typed_value_id(MirType::Bool);
+                let (left, right, op) = match wasm_op {
+                    Op::I32LeU => (inputs[1], inputs[0], BinaryOp::U32Less),
+                    Op::I32GeU => (inputs[0], inputs[1], BinaryOp::U32Less),
+                    _ => unreachable!(),
+                };
+                self.casm_builder.binary_op(op, temp, left, right, None)?;
+                self.casm_builder.binary_op(
+                    BinaryOp::Sub,
+                    result_id,
+                    Value::integer(1),
+                    Value::operand(temp),
+                    None,
+                )?;
+                Ok(Some(result_id))
+            }
 
             // Signed comparison instructions: convert to unsigned by adding 2^31 (flips sign bit)
             // This maps signed range [-2^31, 2^31-1] to unsigned [0, 2^32-1] preserving order
             Op::I32LtS | Op::I32GtS | Op::I32LeS | Op::I32GeS => {
-                let temp1 = self.mir_function.new_typed_value_id(MirType::U32);
-                let instruction1 = Instruction::binary_op(
+                let temp1 = self.new_typed_value_id(MirType::U32);
+                self.casm_builder.binary_op(
                     BinaryOp::U32Add,
                     temp1,
                     inputs[0],
                     Value::integer(0x80000000),
-                );
-                let temp2 = self.mir_function.new_typed_value_id(MirType::U32);
-                let instruction2 = Instruction::binary_op(
+                    None,
+                )?;
+                let temp2 = self.new_typed_value_id(MirType::U32);
+                self.casm_builder.binary_op(
                     BinaryOp::U32Add,
                     temp2,
                     inputs[1],
                     Value::integer(0x80000000),
-                );
-                let result_id = self.mir_function.new_typed_value_id(MirType::Bool);
-                let op = match wasm_op {
-                    Op::I32LtS => BinaryOp::U32Less,
-                    Op::I32GtS => BinaryOp::U32Greater,
-                    Op::I32LeS => BinaryOp::U32LessEqual,
-                    Op::I32GeS => BinaryOp::U32GreaterEqual,
+                    None,
+                )?;
+                let temp = self.new_typed_value_id(MirType::Bool);
+                let (left, right) = match wasm_op {
+                    Op::I32LtS => (temp1, temp2),
+                    Op::I32GtS => (temp2, temp1),
+                    Op::I32LeS => (temp2, temp1),
+                    Op::I32GeS => (temp1, temp2),
                     _ => unreachable!(),
                 };
-                let instruction3 = Instruction::binary_op(
-                    op,
-                    result_id,
-                    Value::operand(temp1),
-                    Value::operand(temp2),
-                );
-                self.get_current_block()?.push_instruction(instruction1);
-                self.get_current_block()?.push_instruction(instruction2);
-                self.get_current_block()?.push_instruction(instruction3);
+                self.casm_builder.binary_op(
+                    BinaryOp::U32Less,
+                    temp,
+                    Value::operand(left),
+                    Value::operand(right),
+                    None,
+                )?;
+                // For "or equal" variants, we apply the same 1 - (a < b) trick as above
+                let result_id = if wasm_op == &Op::I32LeS || wasm_op == &Op::I32GeS {
+                    let result_id = self.new_typed_value_id(MirType::Bool);
+                    self.casm_builder.binary_op(
+                        BinaryOp::Sub,
+                        result_id,
+                        Value::integer(1),
+                        Value::operand(temp),
+                        None,
+                    )?;
+                    result_id
+                } else {
+                    temp
+                };
                 Ok(Some(result_id))
             }
 
             // Zero comparison instruction, constructed by comparing the input to 0
             // TODO : fix type of result_id
             Op::I32Eqz => {
-                let result_id = self.mir_function.new_typed_value_id(MirType::Bool);
-                let instruction = Instruction::binary_op(
+                let result_id = self.new_typed_value_id(MirType::Bool);
+                self.casm_builder.binary_op(
                     BinaryOp::U32Eq,
                     result_id,
                     inputs[0],
                     Value::integer(0),
-                );
-                self.get_current_block()?.push_instruction(instruction);
+                    None,
+                )?;
                 Ok(Some(result_id))
             }
 
             // Assigning a constant to a variable
             Op::I32Const { value } => {
-                let result_id = self.mir_function.new_typed_value_id(MirType::U32);
-                let instruction =
-                    Instruction::assign(result_id, Value::integer(*value as u32), MirType::U32);
-                self.get_current_block()?.push_instruction(instruction);
+                let result_id = self.new_typed_value_id(MirType::U32);
+                self.casm_builder.assign(
+                    result_id,
+                    Value::integer(*value as u32),
+                    &MirType::U32,
+                    None,
+                )?;
                 Ok(Some(result_id))
             }
 
@@ -197,36 +265,21 @@ impl DagToMirContext {
             }
 
             Op::Call { function_index } => {
-                let callee_id = FunctionId::new(*function_index as usize);
-
-                // Get signature from wasm module
-                let program = &module.0;
-                let func_type = program.m.get_func_type(*function_index);
-
-                // Handle param types with proper error handling
-                let param_types: Vec<MirType> = func_type
-                    .ty
-                    .params()
-                    .iter()
-                    .map(|ty| wasm_type_to_mir_type(ty, "unknown", "function call parameters"))
-                    .collect::<Result<Vec<MirType>, DagToMirError>>()?;
-
-                // Handle return types with proper error handling
-                let return_types: Vec<MirType> = func_type
-                    .ty
-                    .results()
-                    .iter()
-                    .map(|ty| wasm_type_to_mir_type(ty, "unknown", "function call return types"))
-                    .collect::<Result<Vec<MirType>, DagToMirError>>()?;
+                let param_types = get_function_parameter_types(module, *function_index)?;
+                let return_types = get_function_return_types(module, *function_index)?;
 
                 let signature = CalleeSignature {
                     param_types,
                     return_types,
                 };
 
-                let result_id = self.mir_function.new_typed_value_id(MirType::U32);
-                let instruction = Instruction::call(vec![result_id], callee_id, inputs, signature);
-                self.get_current_block()?.push_instruction(instruction);
+                let result_id = self.new_typed_value_id(MirType::U32);
+
+                let func_name = get_function_name(module, *function_index);
+
+                self.casm_builder
+                    .lower_call(&func_name, &inputs, &signature, &[result_id])?;
+
                 Ok(Some(result_id))
             }
 
@@ -239,10 +292,12 @@ impl DagToMirContext {
                 let base_address = inputs[0];
                 let cm_address =
                     self.compute_cm_address_from_wasm_address(base_address, memarg.offset)?;
-                let result_id = self.mir_function.new_typed_value_id(MirType::U32);
-                let place = Place::new(cm_address);
-                let instruction = Instruction::load(result_id, place, MirType::U32);
-                self.get_current_block()?.push_instruction(instruction);
+                let result_id = self.new_typed_value_id(MirType::U32);
+
+                // Load u32 from memory (2 slots)
+                self.casm_builder
+                    .load_from_memory(result_id, cm_address, 2)?;
+
                 Ok(Some(result_id))
             }
 
@@ -252,9 +307,24 @@ impl DagToMirContext {
                 let base_address = inputs[0];
                 let cm_address =
                     self.compute_cm_address_from_wasm_address(base_address, memarg.offset)?;
-                let place = Place::new(cm_address);
-                let instruction = Instruction::store(place, inputs[1], MirType::U32);
-                self.get_current_block()?.push_instruction(instruction);
+                let value = inputs[1];
+
+                // Extract value_id from operand
+                let value_id = match value {
+                    Value::Operand(vid) => vid,
+                    _ => {
+                        return Err(DagToCasmError::UnsupportedOperation {
+                            op: "I32Store with non-operand value".to_string(),
+                            function_name: self.casm_builder.layout.name.clone(),
+                            node_idx,
+                            suggestion: "Store operands only".to_string(),
+                        })
+                    }
+                };
+
+                // Store to memory using public API
+                self.casm_builder.store_to_memory(cm_address, value_id)?;
+
                 Ok(None)
             }
 
@@ -262,9 +332,9 @@ impl DagToMirContext {
                 // Unsupported operation
                 let suggestion = "This WASM operation is not yet implemented in the compiler";
 
-                Err(DagToMirError::UnsupportedOperation {
+                Err(DagToCasmError::UnsupportedOperation {
                     op: format!("{:?}", wasm_op),
-                    function_name: self.mir_function.name.clone(),
+                    function_name: self.casm_builder.layout.name.clone(),
                     node_idx,
                     suggestion: suggestion.to_string(),
                 })
diff --git a/crates/wasm/src/main.rs b/crates/wasm/src/main.rs
index 6399c2ff..1c1a4f0b 100644
--- a/crates/wasm/src/main.rs
+++ b/crates/wasm/src/main.rs
@@ -1,7 +1,5 @@
-use cairo_m_compiler_codegen::compile_module;
-use cairo_m_compiler_mir::PassManager;
 use cairo_m_wasm::loader::{BlocklessDagModule, WasmLoadError};
-use cairo_m_wasm::lowering::lower_program_to_mir;
+use cairo_m_wasm::lowering::lower_program_to_casm;
 use clap::Parser;
 use std::process;
 use std::{fs, path::PathBuf};
@@ -27,13 +25,23 @@ struct Args {
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = Args::parse();
     if args.verbose {
-        tracing_subscriber::fmt().with_max_level(Level::INFO).init();
+        tracing_subscriber::fmt()
+            .with_max_level(Level::DEBUG)
+            .init();
     }
 
     let wasm_file = fs::read(&args.input).map_err(|e| WasmLoadError::IoError { source: e })?;
     let module = BlocklessDagModule::from_bytes(&wasm_file)?;
-    let mir_module = lower_program_to_mir(&module, PassManager::standard_pipeline())?;
-    let program = compile_module(&mir_module)?;
+
+    // Print DAG in verbose mode
+    if args.verbose {
+        eprintln!("\n=== Loaded WASM DAG ===\n");
+        eprintln!("{}", module);
+        eprintln!("=== End DAG ===\n");
+    }
+
+    let codegen = lower_program_to_casm(&module)?;
+    let program = codegen.compile()?;
 
     let json = sonic_rs::to_string_pretty(&program).unwrap_or_else(|e| {
         eprintln!("Failed to serialize program: {}", e);
diff --git a/crates/wasm/tests/diff_tests.proptest-regressions b/crates/wasm/tests/diff_tests.proptest-regressions
index 05bc1608..6d53349b 100644
--- a/crates/wasm/tests/diff_tests.proptest-regressions
+++ b/crates/wasm/tests/diff_tests.proptest-regressions
@@ -6,3 +6,4 @@
 # everyone who runs the test benefits from these saved cases.
 cc 287547a69dd3e5dc3bdb65ceb44f7184fc416e6dbffc4aa1cab80bfd2248a7fd # shrinks to a = 0
 cc d399acef85bcbdfbfbdaa3dad18e7d3616d7fb74f31d1363d8e3b6cb18782bfa # shrinks to a = 0
+cc e70117a1a7dbc674352e3ee7424f045bde201ee3ad2da89f1a5e2bc79062b9ab # shrinks to a = 9
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_fib_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_fib_wasm.snap
index c34d47d7..d36a8bca 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_fib_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_fib_wasm.snap
@@ -3,61 +3,45 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: fib.wat"
 ---
 WASM File: fib.wat
-Functions loaded: 1
 
-Module Output:
-module {
-  // Function 0
-  fn fib {
-    parameters: [0]
-    entry: 0
-
-    0:
-      %2 = 1 (u32)
-      %3 = %0 U32LessEqual %2
-      if %3 then jump 3 else jump 1
-
-    1:
-      %4 = 0 (u32)
-      %5 = 2 (u32)
-      %8 = %2 (u32)
-      %10 = %5 (u32)
-      %7 = %4 (u32)
-      %9 = %4 (u32)
-      %6 = %0 (u32)
-      jump 5
-
-    2:
-      jump 8
-
-    3:
-      jump 4
-
-    4:
-      return %0
-
-    5:
-      jump 6
-
-    6:
-      %11 = %10 U32Greater %6
-      %1 = %8 (u32)
-      if %11 then jump 2 else jump 7
-
-    7:
-      %12 = %7 U32Add %8
-      %13 = 1 (u32)
-      %14 = %10 U32Add %13
-      %6 = %6 (u32)
-      %7 = %8 (u32)
-      %8 = %12 (u32)
-      %9 = %12 (u32)
-      %10 = %14 (u32)
-      jump 5
-
-    8:
-      return %1
-
-  }
-
-}
+Program:
+fib:
+   0: 23 1 0 2             // u32([fp + 2], [fp + 3]) = u32(1)
+   1: 28 2 2147483641 4    // [fp + 4] = u32([fp + 2], [fp + 3]) U32Less u32([fp + -6], [fp + -5])
+   2: 9 1 8 _              // [fp + 8] = 1
+   3: 1 8 4 6              // [fp + 6] = [fp + 8] op [fp + 4]
+   4: 14 6 2 _             // if [fp + 6] != 0 jmp rel .fallthrough_2
+   5: 13 4 _ _             // jump rel .L_0
+.fallthrough_2:
+   6: 4 2147483641 0 2147483643 // Return value 0 slot 0: [fp -4] = [fp + -6] + 0
+   7: 4 2147483642 0 2147483644 // Return value 0 slot 1: [fp -3] = [fp + -5] + 0
+   8: 11 _ _ _             // return
+.L_0:
+   9: 23 0 0 9             // u32([fp + 9], [fp + 10]) = u32(0)
+  10: 23 2 0 11            // u32([fp + 11], [fp + 12]) = u32(2)
+  11: 19 2147483641 0 0 13 // u32([fp + 13], [fp + 14]) = u32([fp + -6], [fp + -5]) + u32(0, 0)
+  12: 19 9 0 0 15          // u32([fp + 15], [fp + 16]) = u32([fp + 9], [fp + 10]) + u32(0, 0)
+  13: 19 2 0 0 17          // u32([fp + 17], [fp + 18]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+  14: 19 9 0 0 19          // u32([fp + 19], [fp + 20]) = u32([fp + 9], [fp + 10]) + u32(0, 0)
+  15: 19 11 0 0 21         // u32([fp + 21], [fp + 22]) = u32([fp + 11], [fp + 12]) + u32(0, 0)
+.loop_header_3:
+  16: 28 13 21 23          // [fp + 23] = u32([fp + 13], [fp + 14]) U32Less u32([fp + 21], [fp + 22])
+  17: 14 23 2 _            // if [fp + 23] != 0 jmp rel .br_taken_4
+  18: 13 4 _ _             // jump rel .br_fallthrough_5
+.br_taken_4:
+  19: 19 17 0 0 0          // u32([fp + 0], [fp + 1]) = u32([fp + 17], [fp + 18]) + u32(0, 0)
+  20: 13 15 _ _            // jump rel .L_1
+.br_fallthrough_5:
+  21: 15 15 17 25          // u32([fp + 25], [fp + 26]) = u32([fp + 15], [fp + 16]) U32Add u32([fp + 17], [fp + 18])
+  22: 23 1 0 27            // u32([fp + 27], [fp + 28]) = u32(1)
+  23: 15 21 27 29          // u32([fp + 29], [fp + 30]) = u32([fp + 21], [fp + 22]) U32Add u32([fp + 27], [fp + 28])
+  24: 19 13 0 0 13         // u32([fp + 13], [fp + 14]) = u32([fp + 13], [fp + 14]) + u32(0, 0)
+  25: 19 17 0 0 15         // u32([fp + 15], [fp + 16]) = u32([fp + 17], [fp + 18]) + u32(0, 0)
+  26: 19 25 0 0 17         // u32([fp + 17], [fp + 18]) = u32([fp + 25], [fp + 26]) + u32(0, 0)
+  27: 19 25 0 0 19         // u32([fp + 19], [fp + 20]) = u32([fp + 25], [fp + 26]) + u32(0, 0)
+  28: 19 29 0 0 21         // u32([fp + 21], [fp + 22]) = u32([fp + 29], [fp + 30]) + u32(0, 0)
+  29: 13 2147483628 _ _    // jump rel .loop_header_3
+.L_1:
+  30: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  31: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  32: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_func_call_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_func_call_wasm.snap
index a397b424..6e90d769 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_func_call_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_func_call_wasm.snap
@@ -3,37 +3,21 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: func_call.wat"
 ---
 WASM File: func_call.wat
-Functions loaded: 2
 
-Module Output:
-module {
-  // Function 0
-  fn func_0 {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 U32Add %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-  // Function 1
-  fn func_call {
-    entry: 0
-
-    0:
-      %0 = 15 (u32)
-      %1 = 25 (u32)
-      %2 = call 0(%0, %1)
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-}
+Program:
+func_0:
+   0: 15 2147483639 2147483641 0 // u32([fp + 0], [fp + 1]) = u32([fp + -8], [fp + -7]) U32Add u32([fp + -6], [fp + -5])
+   1: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+   2: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+   3: 11 _ _ _             // return
+func_call:
+   4: 23 15 0 0            // u32([fp + 0], [fp + 1]) = u32(15)
+   5: 23 25 0 2            // u32([fp + 2], [fp + 3]) = u32(25)
+   6: 4 0 0 6              // Arg 0 slot 0: [fp + 6] = [fp + 0] + 0
+   7: 4 1 0 7              // Arg 0 slot 1: [fp + 7] = [fp + 1] + 0
+   8: 4 2 0 8              // Arg 1 slot 0: [fp + 8] = [fp + 2] + 0
+   9: 4 3 0 9              // Arg 1 slot 1: [fp + 9] = [fp + 3] + 0
+  10: 10 12 0 _            // call func_0
+  11: 4 10 0 2147483643    // Return value 0 slot 0: [fp -4] = [fp + 10] + 0
+  12: 4 11 0 2147483644    // Return value 0 slot 1: [fp -3] = [fp + 11] + 0
+  13: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_arithmetic_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_arithmetic_wasm.snap
index ec864fc0..18143bba 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_arithmetic_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_arithmetic_wasm.snap
@@ -3,64 +3,25 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: i32_arithmetic.wat"
 ---
 WASM File: i32_arithmetic.wat
-Functions loaded: 4
 
-Module Output:
-module {
-  // Function 0
-  fn i32_add {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 U32Add %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-  // Function 1
-  fn i32_sub {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 U32Sub %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-  // Function 2
-  fn i32_mul {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 U32Mul %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-  // Function 3
-  fn i32_div_u {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 U32Div %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-}
+Program:
+i32_add:
+   0: 15 2147483639 2147483641 0 // u32([fp + 0], [fp + 1]) = u32([fp + -8], [fp + -7]) U32Add u32([fp + -6], [fp + -5])
+   1: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+   2: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+   3: 11 _ _ _             // return
+i32_sub:
+   4: 16 2147483639 2147483641 0 // u32([fp + 0], [fp + 1]) = u32([fp + -8], [fp + -7]) U32Sub u32([fp + -6], [fp + -5])
+   5: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+   6: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+   7: 11 _ _ _             // return
+i32_mul:
+   8: 17 2147483639 2147483641 0 // u32([fp + 0], [fp + 1]) = u32([fp + -8], [fp + -7]) U32Mul u32([fp + -6], [fp + -5])
+   9: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  10: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  11: 11 _ _ _             // return
+i32_div_u:
+  12: 18 2147483639 2147483641 0 2 // u32([fp + 0], [fp + 1]); u32([fp + 2], [fp + 3]) = u32([fp + -8], [fp + -7]) / u32([fp + -6], [fp + -5])
+  13: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  14: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  15: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_bitwise_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_bitwise_wasm.snap
index 104d4c16..cf05c82b 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_bitwise_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_i32_bitwise_wasm.snap
@@ -3,50 +3,20 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: i32_bitwise.wat"
 ---
 WASM File: i32_bitwise.wat
-Functions loaded: 3
 
-Module Output:
-module {
-  // Function 0
-  fn i32_and {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 & (u32) %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-  // Function 1
-  fn i32_or {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 | (u32) %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-  // Function 2
-  fn i32_xor {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = %0 ^ (u32) %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-}
+Program:
+i32_and:
+   0: 36 2147483639 2147483641 0 // u32([fp + 0], [fp + 1]) = u32([fp + -8], [fp + -7]) & (u32) u32([fp + -6], [fp + -5])
+   1: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+   2: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+   3: 11 _ _ _             // return
+i32_or:
+   4: 37 2147483639 2147483641 0 // u32([fp + 0], [fp + 1]) = u32([fp + -8], [fp + -7]) | (u32) u32([fp + -6], [fp + -5])
+   5: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+   6: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+   7: 11 _ _ _             // return
+i32_xor:
+   8: 38 2147483639 2147483641 0 // u32([fp + 0], [fp + 1]) = u32([fp + -8], [fp + -7]) ^ (u32) u32([fp + -6], [fp + -5])
+   9: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  10: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  11: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_if_statement_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_if_statement_wasm.snap
index 890a3cfb..5311b089 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_if_statement_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_if_statement_wasm.snap
@@ -3,51 +3,41 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: if_statement.wat"
 ---
 WASM File: if_statement.wat
-Functions loaded: 1
 
-Module Output:
-module {
-  // Function 0
-  fn if_statement {
-    parameters: [0]
-    entry: 0
-
-    0:
-      %3 = 3 (u32)
-      %4 = %0 U32Eq %3
-      if %4 then jump 3 else jump 5
-
-    1:
-      %8 = 1 (u32)
-      %9 = %0 U32Add %8
-      %1 = %9 (u32)
-      jump 2
-
-    2:
-      %2 = %1 (u32)
-      jump 4
-
-    3:
-      %10 = 1 (u32)
-      %2 = %10 (u32)
-      jump 4
-
-    4:
-      jump 7
-
-    5:
-      %5 = 2 (u32)
-      %6 = %0 U32Neq %5
-      if %6 then jump 1 else jump 6
-
-    6:
-      %7 = 5 (u32)
-      %1 = %7 (u32)
-      jump 2
-
-    7:
-      return %2
-
-  }
-
-}
+Program:
+if_statement:
+   0: 23 3 0 4             // u32([fp + 4], [fp + 5]) = u32(3)
+   1: 24 2147483641 4 6    // [fp + 6] = u32([fp + -6], [fp + -5]) U32Eq u32([fp + 4], [fp + 5])
+   2: 14 6 2 _             // if [fp + 6] != 0 jmp rel .br_taken_4
+   3: 13 2 _ _             // jump rel .br_fallthrough_5
+.br_taken_4:
+   4: 13 20 _ _            // jump rel .L_2
+.br_fallthrough_5:
+   5: 23 2 0 8             // u32([fp + 8], [fp + 9]) = u32(2)
+   6: 24 2147483641 8 12   // [fp + 12] = u32([fp + -6], [fp + -5]) U32Eq u32([fp + 8], [fp + 9])
+   7: 9 1 14 _             // [fp + 14] = 1
+   8: 1 14 12 10           // [fp + 10] = [fp + 14] op [fp + 12]
+   9: 14 10 2 _            // if [fp + 10] != 0 jmp rel .br_taken_6
+  10: 13 2 _ _             // jump rel .br_fallthrough_7
+.br_taken_6:
+  11: 13 5 _ _             // jump rel .L_0
+.br_fallthrough_7:
+  12: 23 5 0 15            // u32([fp + 15], [fp + 16]) = u32(5)
+  13: 19 15 0 0 0          // u32([fp + 0], [fp + 1]) = u32([fp + 15], [fp + 16]) + u32(0, 0)
+  14: 13 6 _ _             // jump rel .L_1
+.L_0:
+  15: 23 1 0 17            // u32([fp + 17], [fp + 18]) = u32(1)
+  16: 15 2147483641 17 19  // u32([fp + 19], [fp + 20]) = u32([fp + -6], [fp + -5]) U32Add u32([fp + 17], [fp + 18])
+  17: 19 19 0 0 0          // u32([fp + 0], [fp + 1]) = u32([fp + 19], [fp + 20]) + u32(0, 0)
+  18: 13 1 _ _             // jump rel .L_1
+.L_1:
+  19: 19 0 0 0 2           // u32([fp + 2], [fp + 3]) = u32([fp + 0], [fp + 1]) + u32(0, 0)
+  20: 13 5 _ _             // jump rel .L_3
+.L_2:
+  21: 23 1 0 21            // u32([fp + 21], [fp + 22]) = u32(1)
+  22: 19 21 0 0 2          // u32([fp + 2], [fp + 3]) = u32([fp + 21], [fp + 22]) + u32(0, 0)
+  23: 13 1 _ _             // jump rel .L_3
+.L_3:
+  24: 4 2 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 2] + 0
+  25: 4 3 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 3] + 0
+  26: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_load_store_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_load_store_wasm.snap
index b95472d5..fb352888 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_load_store_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_load_store_wasm.snap
@@ -3,155 +3,134 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: load_store.wat"
 ---
 WASM File: load_store.wat
-Functions loaded: 3
 
-Module Output:
-module {
-  // Function 0
-  fn add {
-    parameters: [0, 1]
-    entry: 0
-
-    0:
-      %2 = 0 (u32)
-      %3 = %2 U32Div 2
-      %4 = cast %3 from u32 to felt
-      %5 = 268435454 - %4
-      store %0 -> %5
-      %6 = 4 (u32)
-      %7 = %6 U32Div 2
-      %8 = cast %7 from u32 to felt
-      %9 = 268435454 - %8
-      store %1 -> %9
-      %10 = %2 U32Div 2
-      %11 = cast %10 from u32 to felt
-      %12 = 268435454 - %11
-      %13 = load %12
-      %14 = %6 U32Div 2
-      %15 = cast %14 from u32 to felt
-      %16 = 268435454 - %15
-      %17 = load %16
-      %18 = %13 U32Add %17
-      jump 1
-
-    1:
-      return %18
-
-  }
-
-  // Function 1
-  fn load_store_sum {
-    parameters: [0]
-    entry: 0
-
-    0:
-      %2 = 1 (u32)
-      %3 = 0 (u32)
-      %4 = %0 (u32)
-      %5 = %2 (u32)
-      %6 = %3 (u32)
-      jump 3
-
-    1:
-      %16 = %2 (u32)
-      %18 = %3 (u32)
-      %15 = %0 (u32)
-      %17 = %3 (u32)
-      jump 6
-
-    2:
-      jump 9
-
-    3:
-      jump 4
-
-    4:
-      %7 = %6 U32Div 2
-      %8 = cast %7 from u32 to felt
-      %9 = 268435454 - %8
-      store %5 -> %9
-      %10 = 4 (u32)
-      %11 = %6 U32Add %10
-      %12 = 1 (u32)
-      %13 = %5 U32Add %12
-      %14 = %13 U32LessEqual %4
-      %4 = %4 (u32)
-      %5 = %13 (u32)
-      %6 = %11 (u32)
-      if %14 then jump 3 else jump 5
-
-    5:
-      jump 1
-
-    6:
-      jump 7
-
-    7:
-      %19 = %18 U32Div 2
-      %20 = cast %19 from u32 to felt
-      %21 = 268435454 - %20
-      %22 = load %21
-      %23 = %17 U32Add %22
-      %24 = 4 (u32)
-      %25 = %18 U32Add %24
-      %26 = 1 (u32)
-      %27 = %16 U32Add %26
-      %28 = %27 U32LessEqual %15
-      %15 = %15 (u32)
-      %16 = %27 (u32)
-      %17 = %23 (u32)
-      %18 = %25 (u32)
-      if %28 then jump 6 else jump 8
-
-    8:
-      %1 = %23 (u32)
-      jump 2
-
-    9:
-      return %1
-
-  }
-
-  // Function 2
-  fn load_store_sum_3_with_offsets {
-    entry: 0
-
-    0:
-      %0 = 0 (u32)
-      %1 = 65000 (u32)
-      %2 = %0 U32Div 2
-      %3 = cast %2 from u32 to felt
-      %4 = 268435454 - %3
-      store %1 -> %4
-      %5 = 66000 (u32)
-      %6 = %0 U32Div 2
-      %7 = cast %6 from u32 to felt
-      %8 = 268435452 - %7
-      store %5 -> %8
-      %9 = 67000 (u32)
-      %10 = %0 U32Div 2
-      %11 = cast %10 from u32 to felt
-      %12 = 268435450 - %11
-      store %9 -> %12
-      %13 = %0 U32Div 2
-      %14 = cast %13 from u32 to felt
-      %15 = 268435454 - %14
-      %16 = load %15
-      %17 = %0 U32Div 2
-      %18 = cast %17 from u32 to felt
-      %19 = 268435452 - %18
-      %20 = load %19
-      %21 = %0 U32Div 2
-      %22 = cast %21 from u32 to felt
-      %23 = 268435450 - %22
-      %24 = load %23
-      %25 = %20 U32Add %24
-      %26 = %16 U32Add %25
-      jump 1
-
-    1:
-      return %26
-
-  }
-
-}
+Program:
+add:
+   0: 23 0 0 0             // u32([fp + 0], [fp + 1]) = u32(0)
+   1: 22 0 2 0 2 4         // u32([fp + 2], [fp + 3]); u32([fp + 4], [fp + 5]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+   2: 9 268435454 8 _      // [fp + 8] = 268435454
+   3: 1 8 2 6              // [fp + 6] = [fp + 8] op [fp + 2]
+   4: 44 6 0 2147483639    // [[fp + 6] + 0] = [fp + -8] (store limb 1/2)
+   5: 44 6 1 2147483640    // [[fp + 6] + 1] = [fp + -7] (store limb 2/2)
+   6: 23 4 0 9             // u32([fp + 9], [fp + 10]) = u32(4)
+   7: 22 9 2 0 11 13       // u32([fp + 11], [fp + 12]); u32([fp + 13], [fp + 14]) = u32([fp + 9], [fp + 10]) / u32(2, 0)
+   8: 9 268435454 17 _     // [fp + 17] = 268435454
+   9: 1 17 11 15           // [fp + 15] = [fp + 17] op [fp + 11]
+  10: 44 15 0 2147483641   // [[fp + 15] + 0] = [fp + -6] (store limb 1/2)
+  11: 44 15 1 2147483642   // [[fp + 15] + 1] = [fp + -5] (store limb 2/2)
+  12: 22 0 2 0 18 20       // u32([fp + 18], [fp + 19]); u32([fp + 20], [fp + 21]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+  13: 9 268435454 24 _     // [fp + 24] = 268435454
+  14: 1 24 18 22           // [fp + 22] = [fp + 24] op [fp + 18]
+  15: 8 22 0 25            // [fp + 25] = [[fp + 22] + 0] (load limb 1/2)
+  16: 8 22 1 26            // [fp + 26] = [[fp + 22] + 1] (load limb 2/2)
+  17: 22 9 2 0 27 29       // u32([fp + 27], [fp + 28]); u32([fp + 29], [fp + 30]) = u32([fp + 9], [fp + 10]) / u32(2, 0)
+  18: 9 268435454 33 _     // [fp + 33] = 268435454
+  19: 1 33 27 31           // [fp + 31] = [fp + 33] op [fp + 27]
+  20: 8 31 0 34            // [fp + 34] = [[fp + 31] + 0] (load limb 1/2)
+  21: 8 31 1 35            // [fp + 35] = [[fp + 31] + 1] (load limb 2/2)
+  22: 15 25 34 36          // u32([fp + 36], [fp + 37]) = u32([fp + 25], [fp + 26]) U32Add u32([fp + 34], [fp + 35])
+  23: 4 36 0 2147483643    // Return value 0 slot 0: [fp -4] = [fp + 36] + 0
+  24: 4 37 0 2147483644    // Return value 0 slot 1: [fp -3] = [fp + 37] + 0
+  25: 11 _ _ _             // return
+  26: 23 1 0 2             // u32([fp + 2], [fp + 3]) = u32(1)
+  27: 23 0 0 4             // u32([fp + 4], [fp + 5]) = u32(0)
+  28: 19 2147483641 0 0 6  // u32([fp + 6], [fp + 7]) = u32([fp + -6], [fp + -5]) + u32(0, 0)
+  29: 19 2 0 0 8           // u32([fp + 8], [fp + 9]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+load_store_sum:
+  30: 19 4 0 0 10          // u32([fp + 10], [fp + 11]) = u32([fp + 4], [fp + 5]) + u32(0, 0)
+.loop_header_2:
+  31: 22 10 2 0 12 14      // u32([fp + 12], [fp + 13]); u32([fp + 14], [fp + 15]) = u32([fp + 10], [fp + 11]) / u32(2, 0)
+  32: 9 268435454 18 _     // [fp + 18] = 268435454
+  33: 1 18 12 16           // [fp + 16] = [fp + 18] op [fp + 12]
+  34: 44 16 0 8            // [[fp + 16] + 0] = [fp + 8] (store limb 1/2)
+  35: 44 16 1 9            // [[fp + 16] + 1] = [fp + 9] (store limb 2/2)
+  36: 23 4 0 19            // u32([fp + 19], [fp + 20]) = u32(4)
+  37: 15 10 19 21          // u32([fp + 21], [fp + 22]) = u32([fp + 10], [fp + 11]) U32Add u32([fp + 19], [fp + 20])
+  38: 23 1 0 23            // u32([fp + 23], [fp + 24]) = u32(1)
+  39: 15 8 23 25           // u32([fp + 25], [fp + 26]) = u32([fp + 8], [fp + 9]) U32Add u32([fp + 23], [fp + 24])
+  40: 28 6 25 27           // [fp + 27] = u32([fp + 6], [fp + 7]) U32Less u32([fp + 25], [fp + 26])
+  41: 9 1 31 _             // [fp + 31] = 1
+  42: 1 31 27 29           // [fp + 29] = [fp + 31] op [fp + 27]
+  43: 14 29 2 _            // if [fp + 29] != 0 jmp rel .br_taken_3
+  44: 13 8 _ _             // jump rel .br_fallthrough_4
+.br_taken_3:
+  45: 19 6 0 0 6           // u32([fp + 6], [fp + 7]) = u32([fp + 6], [fp + 7]) + u32(0, 0)
+  46: 19 25 0 0 8          // u32([fp + 8], [fp + 9]) = u32([fp + 25], [fp + 26]) + u32(0, 0)
+  47: 19 21 0 0 10         // u32([fp + 10], [fp + 11]) = u32([fp + 21], [fp + 22]) + u32(0, 0)
+  48: 13 2147483626 _ _    // jump rel .loop_header_2
+.br_fallthrough_4:
+  49: 13 1 _ _             // jump rel .L_0
+.L_0:
+  50: 19 2147483641 0 0 32 // u32([fp + 32], [fp + 33]) = u32([fp + -6], [fp + -5]) + u32(0, 0)
+  51: 19 2 0 0 34          // u32([fp + 34], [fp + 35]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+  52: 19 4 0 0 36          // u32([fp + 36], [fp + 37]) = u32([fp + 4], [fp + 5]) + u32(0, 0)
+  53: 19 4 0 0 38          // u32([fp + 38], [fp + 39]) = u32([fp + 4], [fp + 5]) + u32(0, 0)
+.loop_header_5:
+  54: 22 38 2 0 40 42      // u32([fp + 40], [fp + 41]); u32([fp + 42], [fp + 43]) = u32([fp + 38], [fp + 39]) / u32(2, 0)
+  55: 9 268435454 46 _     // [fp + 46] = 268435454
+  56: 1 46 40 44           // [fp + 44] = [fp + 46] op [fp + 40]
+  57: 8 44 0 47            // [fp + 47] = [[fp + 44] + 0] (load limb 1/2)
+  58: 8 44 1 48            // [fp + 48] = [[fp + 44] + 1] (load limb 2/2)
+  59: 15 36 47 49          // u32([fp + 49], [fp + 50]) = u32([fp + 36], [fp + 37]) U32Add u32([fp + 47], [fp + 48])
+  60: 23 4 0 51            // u32([fp + 51], [fp + 52]) = u32(4)
+  61: 15 38 51 53          // u32([fp + 53], [fp + 54]) = u32([fp + 38], [fp + 39]) U32Add u32([fp + 51], [fp + 52])
+  62: 23 1 0 55            // u32([fp + 55], [fp + 56]) = u32(1)
+  63: 15 34 55 57          // u32([fp + 57], [fp + 58]) = u32([fp + 34], [fp + 35]) U32Add u32([fp + 55], [fp + 56])
+  64: 28 32 57 59          // [fp + 59] = u32([fp + 32], [fp + 33]) U32Less u32([fp + 57], [fp + 58])
+  65: 9 1 63 _             // [fp + 63] = 1
+  66: 1 63 59 61           // [fp + 61] = [fp + 63] op [fp + 59]
+  67: 14 61 2 _            // if [fp + 61] != 0 jmp rel .br_taken_6
+  68: 13 10 _ _            // jump rel .br_fallthrough_7
+.br_taken_6:
+  69: 19 32 0 0 32         // u32([fp + 32], [fp + 33]) = u32([fp + 32], [fp + 33]) + u32(0, 0)
+  70: 19 57 0 0 34         // u32([fp + 34], [fp + 35]) = u32([fp + 57], [fp + 58]) + u32(0, 0)
+  71: 19 49 0 0 36         // u32([fp + 36], [fp + 37]) = u32([fp + 49], [fp + 50]) + u32(0, 0)
+  72: 19 53 0 0 38         // u32([fp + 38], [fp + 39]) = u32([fp + 53], [fp + 54]) + u32(0, 0)
+  73: 13 2147483623 _ _    // jump rel .loop_header_5
+.br_fallthrough_7:
+  74: 19 49 0 0 0          // u32([fp + 0], [fp + 1]) = u32([fp + 49], [fp + 50]) + u32(0, 0)
+  75: 13 1 _ _             // jump rel .L_1
+.L_1:
+  76: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  77: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  78: 11 _ _ _             // return
+  79: 23 0 0 0             // u32([fp + 0], [fp + 1]) = u32(0)
+  80: 23 65000 0 2         // u32([fp + 2], [fp + 3]) = u32(65000)
+  81: 22 0 2 0 4 6         // u32([fp + 4], [fp + 5]); u32([fp + 6], [fp + 7]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+  82: 9 268435454 10 _     // [fp + 10] = 268435454
+  83: 1 10 4 8             // [fp + 8] = [fp + 10] op [fp + 4]
+  84: 44 8 0 2             // [[fp + 8] + 0] = [fp + 2] (store limb 1/2)
+  85: 44 8 1 3             // [[fp + 8] + 1] = [fp + 3] (store limb 2/2)
+  86: 23 464 1 11          // u32([fp + 11], [fp + 12]) = u32(66000)
+  87: 22 0 2 0 13 15       // u32([fp + 13], [fp + 14]); u32([fp + 15], [fp + 16]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+  88: 9 268435452 19 _     // [fp + 19] = 268435452
+  89: 1 19 13 17           // [fp + 17] = [fp + 19] op [fp + 13]
+  90: 44 17 0 11           // [[fp + 17] + 0] = [fp + 11] (store limb 1/2)
+  91: 44 17 1 12           // [[fp + 17] + 1] = [fp + 12] (store limb 2/2)
+  92: 23 1464 1 20         // u32([fp + 20], [fp + 21]) = u32(67000)
+  93: 22 0 2 0 22 24       // u32([fp + 22], [fp + 23]); u32([fp + 24], [fp + 25]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+  94: 9 268435450 28 _     // [fp + 28] = 268435450
+  95: 1 28 22 26           // [fp + 26] = [fp + 28] op [fp + 22]
+  96: 44 26 0 20           // [[fp + 26] + 0] = [fp + 20] (store limb 1/2)
+  97: 44 26 1 21           // [[fp + 26] + 1] = [fp + 21] (store limb 2/2)
+  98: 22 0 2 0 29 31       // u32([fp + 29], [fp + 30]); u32([fp + 31], [fp + 32]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+  99: 9 268435454 35 _     // [fp + 35] = 268435454
+load_store_sum_3_with_offsets:
+ 100: 1 35 29 33           // [fp + 33] = [fp + 35] op [fp + 29]
+ 101: 8 33 0 36            // [fp + 36] = [[fp + 33] + 0] (load limb 1/2)
+ 102: 8 33 1 37            // [fp + 37] = [[fp + 33] + 1] (load limb 2/2)
+ 103: 22 0 2 0 38 40       // u32([fp + 38], [fp + 39]); u32([fp + 40], [fp + 41]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+ 104: 9 268435452 44 _     // [fp + 44] = 268435452
+ 105: 1 44 38 42           // [fp + 42] = [fp + 44] op [fp + 38]
+ 106: 8 42 0 45            // [fp + 45] = [[fp + 42] + 0] (load limb 1/2)
+ 107: 8 42 1 46            // [fp + 46] = [[fp + 42] + 1] (load limb 2/2)
+ 108: 22 0 2 0 47 49       // u32([fp + 47], [fp + 48]); u32([fp + 49], [fp + 50]) = u32([fp + 0], [fp + 1]) / u32(2, 0)
+ 109: 9 268435450 53 _     // [fp + 53] = 268435450
+ 110: 1 53 47 51           // [fp + 51] = [fp + 53] op [fp + 47]
+ 111: 8 51 0 54            // [fp + 54] = [[fp + 51] + 0] (load limb 1/2)
+ 112: 8 51 1 55            // [fp + 55] = [[fp + 51] + 1] (load limb 2/2)
+ 113: 15 45 54 56          // u32([fp + 56], [fp + 57]) = u32([fp + 45], [fp + 46]) U32Add u32([fp + 54], [fp + 55])
+ 114: 15 36 56 58          // u32([fp + 58], [fp + 59]) = u32([fp + 36], [fp + 37]) U32Add u32([fp + 56], [fp + 57])
+ 115: 4 58 0 2147483643    // Return value 0 slot 0: [fp -4] = [fp + 58] + 0
+ 116: 4 59 0 2147483644    // Return value 0 slot 1: [fp -3] = [fp + 59] + 0
+ 117: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_locals_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_locals_wasm.snap
index 911b234d..e0cbda96 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_locals_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_locals_wasm.snap
@@ -3,23 +3,12 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: locals.wat"
 ---
 WASM File: locals.wat
-Functions loaded: 1
 
-Module Output:
-module {
-  // Function 0
-  fn locals {
-    entry: 0
-
-    0:
-      %0 = 10 (u32)
-      %1 = 5 (u32)
-      %2 = %0 U32Add %1
-      jump 1
-
-    1:
-      return %2
-
-  }
-
-}
+Program:
+locals:
+   0: 23 10 0 0            // u32([fp + 0], [fp + 1]) = u32(10)
+   1: 23 5 0 2             // u32([fp + 2], [fp + 3]) = u32(5)
+   2: 15 0 2 4             // u32([fp + 4], [fp + 5]) = u32([fp + 0], [fp + 1]) U32Add u32([fp + 2], [fp + 3])
+   3: 4 4 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 4] + 0
+   4: 4 5 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 5] + 0
+   5: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_nested_loop_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_nested_loop_wasm.snap
index f4a656ff..0424c18f 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_nested_loop_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_nested_loop_wasm.snap
@@ -3,77 +3,51 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: nested_loop.wat"
 ---
 WASM File: nested_loop.wat
-Functions loaded: 1
 
-Module Output:
-module {
-  // Function 0
-  fn nested_loop {
-    parameters: [0]
-    entry: 0
-
-    0:
-      %2 = 0 (u32)
-      %5 = %2 (u32)
-      %4 = %2 (u32)
-      %6 = %2 (u32)
-      %3 = %0 (u32)
-      jump 2
-
-    1:
-      jump 11
-
-    2:
-      jump 3
-
-    3:
-      %9 = %4 U32Less %3
-      if %9 then jump 6 else jump 5
-
-    4:
-      %18 = 1 (u32)
-      %19 = %4 U32Add %18
-      %3 = %3 (u32)
-      %4 = %19 (u32)
-      %5 = %7 (u32)
-      %6 = %8 (u32)
-      jump 2
-
-    5:
-      %1 = %6 (u32)
-      jump 1
-
-    6:
-      %10 = 0 (u32)
-      %12 = %10 (u32)
-      %13 = %6 (u32)
-      %11 = %4 (u32)
-      jump 7
-
-    7:
-      jump 8
-
-    8:
-      %14 = %12 U32Less %11
-      if %14 then jump 10 else jump 9
-
-    9:
-      %8 = %13 (u32)
-      %7 = %12 (u32)
-      jump 4
-
-    10:
-      %15 = %13 U32Add %11
-      %16 = 1 (u32)
-      %17 = %12 U32Add %16
-      %11 = %11 (u32)
-      %12 = %17 (u32)
-      %13 = %15 (u32)
-      jump 7
-
-    11:
-      return %1
-
-  }
-
-}
+Program:
+nested_loop:
+   0: 23 0 0 2             // u32([fp + 2], [fp + 3]) = u32(0)
+   1: 19 2147483641 0 0 4  // u32([fp + 4], [fp + 5]) = u32([fp + -6], [fp + -5]) + u32(0, 0)
+   2: 19 2 0 0 6           // u32([fp + 6], [fp + 7]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+   3: 19 2 0 0 8           // u32([fp + 8], [fp + 9]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+   4: 19 2 0 0 10          // u32([fp + 10], [fp + 11]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+.loop_header_1:
+   5: 28 6 4 16            // [fp + 16] = u32([fp + 6], [fp + 7]) U32Less u32([fp + 4], [fp + 5])
+   6: 14 16 2 _            // if [fp + 16] != 0 jmp rel .fallthrough_4
+   7: 13 37 _ _            // jump rel .L_3
+.fallthrough_4:
+   8: 23 0 0 18            // u32([fp + 18], [fp + 19]) = u32(0)
+   9: 19 6 0 0 20          // u32([fp + 20], [fp + 21]) = u32([fp + 6], [fp + 7]) + u32(0, 0)
+  10: 19 18 0 0 22         // u32([fp + 22], [fp + 23]) = u32([fp + 18], [fp + 19]) + u32(0, 0)
+  11: 19 10 0 0 24         // u32([fp + 24], [fp + 25]) = u32([fp + 10], [fp + 11]) + u32(0, 0)
+.loop_header_5:
+  12: 28 22 20 26          // [fp + 26] = u32([fp + 22], [fp + 23]) U32Less u32([fp + 20], [fp + 21])
+  13: 14 26 2 _            // if [fp + 26] != 0 jmp rel .fallthrough_7
+  14: 13 11 _ _            // jump rel .L_6
+.fallthrough_7:
+  15: 15 24 20 28          // u32([fp + 28], [fp + 29]) = u32([fp + 24], [fp + 25]) U32Add u32([fp + 20], [fp + 21])
+  16: 23 1 0 30            // u32([fp + 30], [fp + 31]) = u32(1)
+  17: 15 22 30 32          // u32([fp + 32], [fp + 33]) = u32([fp + 22], [fp + 23]) U32Add u32([fp + 30], [fp + 31])
+  18: 19 20 0 0 20         // u32([fp + 20], [fp + 21]) = u32([fp + 20], [fp + 21]) + u32(0, 0)
+  19: 19 32 0 0 22         // u32([fp + 22], [fp + 23]) = u32([fp + 32], [fp + 33]) + u32(0, 0)
+  20: 19 28 0 0 24         // u32([fp + 24], [fp + 25]) = u32([fp + 28], [fp + 29]) + u32(0, 0)
+  21: 13 2147483635 _ _    // jump rel .loop_header_5
+.L_6:
+  22: 19 22 0 0 12         // u32([fp + 12], [fp + 13]) = u32([fp + 22], [fp + 23]) + u32(0, 0)
+  23: 19 24 0 0 14         // u32([fp + 14], [fp + 15]) = u32([fp + 24], [fp + 25]) + u32(0, 0)
+  24: 13 1 _ _             // jump rel .L_2
+.L_2:
+  25: 23 1 0 34            // u32([fp + 34], [fp + 35]) = u32(1)
+  26: 15 6 34 36           // u32([fp + 36], [fp + 37]) = u32([fp + 6], [fp + 7]) U32Add u32([fp + 34], [fp + 35])
+  27: 19 4 0 0 4           // u32([fp + 4], [fp + 5]) = u32([fp + 4], [fp + 5]) + u32(0, 0)
+  28: 19 36 0 0 6          // u32([fp + 6], [fp + 7]) = u32([fp + 36], [fp + 37]) + u32(0, 0)
+  29: 19 12 0 0 8          // u32([fp + 8], [fp + 9]) = u32([fp + 12], [fp + 13]) + u32(0, 0)
+  30: 19 14 0 0 10         // u32([fp + 10], [fp + 11]) = u32([fp + 14], [fp + 15]) + u32(0, 0)
+  31: 13 2147483609 _ _    // jump rel .loop_header_1
+.L_3:
+  32: 19 10 0 0 0          // u32([fp + 0], [fp + 1]) = u32([fp + 10], [fp + 11]) + u32(0, 0)
+  33: 13 1 _ _             // jump rel .L_0
+.L_0:
+  34: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  35: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  36: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_if_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_if_wasm.snap
index 99f38683..7e97c855 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_if_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_if_wasm.snap
@@ -3,36 +3,24 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: simple_if.wat"
 ---
 WASM File: simple_if.wat
-Functions loaded: 1
 
-Module Output:
-module {
-  // Function 0
-  fn simple_if {
-    parameters: [0]
-    entry: 0
-
-    0:
-      %2 = 5 (u32)
-      %3 = %0 U32Greater %2
-      if %3 then jump 1 else jump 3
-
-    1:
-      %4 = 10 (u32)
-      %5 = %0 U32Add %4
-      %1 = %5 (u32)
-      jump 2
-
-    2:
-      jump 4
-
-    3:
-      %1 = %0 (u32)
-      jump 2
-
-    4:
-      return %1
-
-  }
-
-}
+Program:
+simple_if:
+   0: 23 5 0 2             // u32([fp + 2], [fp + 3]) = u32(5)
+   1: 28 2 2147483641 4    // [fp + 4] = u32([fp + 2], [fp + 3]) U32Less u32([fp + -6], [fp + -5])
+   2: 14 4 2 _             // if [fp + 4] != 0 jmp rel .br_taken_2
+   3: 13 2 _ _             // jump rel .br_fallthrough_3
+.br_taken_2:
+   4: 13 4 _ _             // jump rel .L_0
+.br_fallthrough_3:
+   5: 19 2147483641 0 0 0  // u32([fp + 0], [fp + 1]) = u32([fp + -6], [fp + -5]) + u32(0, 0)
+   6: 13 6 _ _             // jump rel .L_1
+.L_0:
+   7: 23 10 0 6            // u32([fp + 6], [fp + 7]) = u32(10)
+   8: 15 2147483641 6 8    // u32([fp + 8], [fp + 9]) = u32([fp + -6], [fp + -5]) U32Add u32([fp + 6], [fp + 7])
+   9: 19 8 0 0 0           // u32([fp + 0], [fp + 1]) = u32([fp + 8], [fp + 9]) + u32(0, 0)
+  10: 13 1 _ _             // jump rel .L_1
+.L_1:
+  11: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  12: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  13: 11 _ _ _             // return
diff --git a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_loop_wasm.snap b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_loop_wasm.snap
index 6cf0af77..771857e1 100644
--- a/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_loop_wasm.snap
+++ b/crates/wasm/tests/snapshots/wasm_to_mir_tests__convert_simple_loop_wasm.snap
@@ -3,45 +3,29 @@ source: crates/wasm/tests/wasm_to_mir_tests.rs
 description: "WASM to MIR snapshot: simple_loop.wat"
 ---
 WASM File: simple_loop.wat
-Functions loaded: 1
 
-Module Output:
-module {
-  // Function 0
-  fn simple_loop {
-    parameters: [0]
-    entry: 0
-
-    0:
-      %2 = 0 (u32)
-      %4 = %2 (u32)
-      %5 = %2 (u32)
-      %3 = %0 (u32)
-      jump 2
-
-    1:
-      jump 5
-
-    2:
-      jump 3
-
-    3:
-      %6 = %5 U32Add %4
-      %7 = 1 (u32)
-      %8 = %4 U32Add %7
-      %9 = %8 U32Less %3
-      %3 = %3 (u32)
-      %4 = %8 (u32)
-      %5 = %6 (u32)
-      if %9 then jump 2 else jump 4
-
-    4:
-      %1 = %6 (u32)
-      jump 1
-
-    5:
-      return %1
-
-  }
-
-}
+Program:
+simple_loop:
+   0: 23 0 0 2             // u32([fp + 2], [fp + 3]) = u32(0)
+   1: 19 2147483641 0 0 4  // u32([fp + 4], [fp + 5]) = u32([fp + -6], [fp + -5]) + u32(0, 0)
+   2: 19 2 0 0 6           // u32([fp + 6], [fp + 7]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+   3: 19 2 0 0 8           // u32([fp + 8], [fp + 9]) = u32([fp + 2], [fp + 3]) + u32(0, 0)
+.loop_header_1:
+   4: 15 8 6 10            // u32([fp + 10], [fp + 11]) = u32([fp + 8], [fp + 9]) U32Add u32([fp + 6], [fp + 7])
+   5: 23 1 0 12            // u32([fp + 12], [fp + 13]) = u32(1)
+   6: 15 6 12 14           // u32([fp + 14], [fp + 15]) = u32([fp + 6], [fp + 7]) U32Add u32([fp + 12], [fp + 13])
+   7: 28 14 4 16           // [fp + 16] = u32([fp + 14], [fp + 15]) U32Less u32([fp + 4], [fp + 5])
+   8: 14 16 2 _            // if [fp + 16] != 0 jmp rel .br_taken_2
+   9: 13 8 _ _             // jump rel .br_fallthrough_3
+.br_taken_2:
+  10: 19 4 0 0 4           // u32([fp + 4], [fp + 5]) = u32([fp + 4], [fp + 5]) + u32(0, 0)
+  11: 19 14 0 0 6          // u32([fp + 6], [fp + 7]) = u32([fp + 14], [fp + 15]) + u32(0, 0)
+  12: 19 10 0 0 8          // u32([fp + 8], [fp + 9]) = u32([fp + 10], [fp + 11]) + u32(0, 0)
+  13: 13 2147483635 _ _    // jump rel .loop_header_1
+.br_fallthrough_3:
+  14: 19 10 0 0 0          // u32([fp + 0], [fp + 1]) = u32([fp + 10], [fp + 11]) + u32(0, 0)
+  15: 13 1 _ _             // jump rel .L_0
+.L_0:
+  16: 4 0 0 2147483643     // Return value 0 slot 0: [fp -4] = [fp + 0] + 0
+  17: 4 1 0 2147483644     // Return value 0 slot 1: [fp -3] = [fp + 1] + 0
+  18: 11 _ _ _             // return
diff --git a/crates/wasm/tests/test_utils.rs b/crates/wasm/tests/test_utils.rs
index 77ec0438..4fc6cafe 100644
--- a/crates/wasm/tests/test_utils.rs
+++ b/crates/wasm/tests/test_utils.rs
@@ -8,10 +8,8 @@ use std::sync::{Arc, LazyLock, Mutex};
 
 use cairo_m_common::Program;
 /// These tests compare the output of the compiled cairo-m with result from the womir interpreter
-use cairo_m_compiler_codegen::compile_module;
-use cairo_m_compiler_mir::PassManager;
 use cairo_m_wasm::loader::BlocklessDagModule;
-use cairo_m_wasm::lowering::lower_program_to_mir;
+use cairo_m_wasm::lowering::lower_program_to_casm;
 use wasmtime::{Engine, Module};
 
 use cairo_m_common::abi_codec::CairoMValue;
@@ -42,7 +40,9 @@ static WASMTIME_MODULES: LazyLock<Mutex<HashMap<u64, Module>>> =
 /// Else, it will be returned from the cache.
 pub fn get_or_build_wasmtime_module(bytes: &[u8]) -> Module {
     let key = hash_bytes(bytes);
-    let mut cache = WASMTIME_MODULES.lock().unwrap();
+    let mut cache = WASMTIME_MODULES
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
     if let Some(m) = cache.get(&key) {
         return m.clone();
     }
@@ -56,13 +56,16 @@ pub fn get_or_build_wasmtime_module(bytes: &[u8]) -> Module {
 /// Else, it will be returned from the cache.
 pub fn get_or_build_cairo_program(bytes: &[u8]) -> Arc<Program> {
     let key = hash_bytes(bytes);
-    let mut cache = COMPILED_PROGRAMS.lock().unwrap();
+    // Handle poisoned mutex gracefully - recover the data even if a previous test panicked
+    let mut cache = COMPILED_PROGRAMS
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
     if let Some(p) = cache.get(&key) {
         return Arc::clone(p);
     }
     let dag_module = BlocklessDagModule::from_bytes(bytes).unwrap();
-    let mir_module = lower_program_to_mir(&dag_module, PassManager::standard_pipeline()).unwrap();
-    let compiled_module = compile_module(&mir_module).unwrap();
+    let codegen = lower_program_to_casm(&dag_module).unwrap();
+    let compiled_module = codegen.compile().unwrap();
     let arc = Arc::new(compiled_module);
     cache.insert(key, Arc::clone(&arc));
     arc
@@ -72,7 +75,9 @@ pub fn get_or_build_cairo_program(bytes: &[u8]) -> Arc<Program> {
 /// It builds the project the first time it is called
 /// and then skips subsequent calls.
 pub fn ensure_rust_wasm_built(project_path: &str) {
-    let mut built_projects = BUILT_RUST_PROJECTS.lock().unwrap();
+    let mut built_projects = BUILT_RUST_PROJECTS
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
 
     if !built_projects.contains(project_path) {
         build_wasm_from_rust(&PathBuf::from(project_path));
diff --git a/crates/wasm/tests/wasm_to_mir_tests.rs b/crates/wasm/tests/wasm_to_mir_tests.rs
index f426a8b6..748b1813 100644
--- a/crates/wasm/tests/wasm_to_mir_tests.rs
+++ b/crates/wasm/tests/wasm_to_mir_tests.rs
@@ -3,9 +3,8 @@
 use insta::assert_snapshot;
 
 // Use the loader from our src module
-use cairo_m_compiler_mir::{PassManager, PrettyPrint};
 use cairo_m_wasm::loader::BlocklessDagModule;
-use cairo_m_wasm::lowering::lower_program_to_mir;
+use cairo_m_wasm::lowering::lower_program_to_casm;
 use wat::parse_file;
 
 /// A macro to define a WASM to MIR conversion test case
@@ -21,16 +20,14 @@ macro_rules! wasm_test {
             let wasm_bytes = parse_file(wat_file_path).unwrap();
             let module = BlocklessDagModule::from_bytes(&wasm_bytes).unwrap();
             // Lower to MIR without any optimizations
-            let mir_module = lower_program_to_mir(&module, PassManager::no_opt_pipeline()).unwrap();
+            let program = lower_program_to_casm(&module).unwrap();
 
             // Create snapshot content
-            let snapshot_content = {
-                let module_output = mir_module.pretty_print(0);
-                format!("WASM File: {}\nFunctions loaded: {}\n\nModule Output:\n{}",
-                    $file_name, mir_module.function_count(),
-                    if module_output.is_empty() { "No functions found" } else { &module_output }
-                )
-            };
+            let snapshot_content = format!(
+                "WASM File: {}\n\nProgram:\n{}",
+                $file_name,
+                program.debug_instructions()
+            );
 
             insta::with_settings!({
                 description => format!("WASM to MIR snapshot: {}", $file_name).as_str(),