diff --git a/sec/codegen.c b/sec/codegen.c
index 6dd3f9b..f549891 100644
--- a/sec/codegen.c
+++ b/sec/codegen.c
@@ -1097,6 +1097,280 @@ static SeDataLabel* emit_nth_addr(SeCodegen* cg, AstNode* node) {
     return label;
 }
 
+// Check if a node is a "simple" expression that can be evaluated into R1 without
+// PUSH/POP overhead (constants, simple variable references).
+static bool is_simple_operand(SeCodegen* cg, AstNode* node) {
+    if (!node) return false;
+    if (node->kind == AST_NUMBER) return true;
+    if (node->kind == AST_NIL || node->kind == AST_TRUE || node->kind == AST_FALSE) return true;
+    if (node->kind == AST_KEYWORD) return true;
+    if (node->kind == AST_SYMBOL) {
+        int32_t val;
+        if (is_constant(cg, node->as.symbol.name, &val)) return true;
+    }
+    return false;
+}
+
+// Emit a simple expression directly into the specified register (R0 or R1).
+// Only call this when is_simple_operand() returns true.
+static void emit_simple_to_reg(SeCodegen* cg, AstNode* node, const char* reg) {
+    if (node->kind == AST_NUMBER) {
+        emit_line(cg, "LOADI %s, 0x%02X", reg, node->as.number & 0xFF);
+        return;
+    }
+    if (node->kind == AST_NIL) { emit_line(cg, "LOADI %s, 0xFF", reg); return; }
+    if (node->kind == AST_TRUE) { emit_line(cg, "LOADI %s, 1", reg); return; }
+    if (node->kind == AST_FALSE) { emit_line(cg, "LOADI %s, 0", reg); return; }
+    if (node->kind == AST_KEYWORD) {
+        for (size_t i = 0; i < cg->keyword_count; i++) {
+            if (strcmp(cg->keywords[i], node->as.symbol.name) == 0) {
+                emit_line(cg, "LOADI %s, 0x%02X", reg, i & 0xFF);
+                return;
+            }
+        }
+    }
+    if (node->kind == AST_SYMBOL) {
+        int32_t val;
+        if (is_constant(cg, node->as.symbol.name, &val)) {
+            emit_line(cg, "LOADI %s, 0x%02X", reg, val & 0xFF);
+            return;
+        }
+    }
+}
+
+// Emit comparison operands: left into R0, right into R1, with CMP.
+// For GT and LE, operand order is swapped (eval right first).
+// For signed comparisons, XOR 0x80 bias is applied.
+// Returns: after CMP, the appropriate jump instruction depends on the comparison type.
+static void emit_cmp_operands(SeCodegen* cg, AstNode* node, bool swap) {
+    AstNode* first = swap ? node->as.binary.right : node->as.binary.left;
+    AstNode* second = swap ? node->as.binary.left : node->as.binary.right;
+    bool is_sgn = expr_is_signed(cg, node->as.binary.left) ||
+                  expr_is_signed(cg, node->as.binary.right);
+
+    if (!expr_is_16bit(cg, first) && !expr_is_16bit(cg, second)) {
+        // 8-bit comparison - optimized paths
+        if (is_simple_operand(cg, second)) {
+            emit_expr(cg, first);
+            emit_simple_to_reg(cg, second, "R1");
+        } else if (is_simple_operand(cg, first)) {
+            emit_expr(cg, second);
+            emit_line(cg, "MOV R1, R0");
+            emit_simple_to_reg(cg, first, "R0");
+        } else {
+            emit_expr(cg, first);
+            emit_line(cg, "PUSH R0");
+            emit_expr(cg, second);
+            emit_line(cg, "MOV R1, R0");
+            emit_line(cg, "POP R0");
+        }
+        if (is_sgn) {
+            emit_line(cg, "PUSH R6");
+            emit_line(cg, "LOADI R6, 0x80");
+            emit_line(cg, "XOR R0, R6");
+            emit_line(cg, "XOR R1, R6");
+            emit_line(cg, "POP R6");
+        }
+        emit_line(cg, "CMP R0, R1");
+    } else {
+        // Fallback to non-fused for 16-bit (emit as expression producing 0/1)
+        // This path shouldn't normally be reached for branch fusion.
+        emit_expr(cg, first);
+        emit_line(cg, "PUSH R0");
+        emit_expr(cg, second);
+        emit_line(cg, "MOV R1, R0");
+        emit_line(cg, "POP R0");
+        if (is_sgn) {
+            emit_line(cg, "PUSH R6");
+            emit_line(cg, "LOADI R6, 0x80");
+            emit_line(cg, "XOR R0, R6");
+            emit_line(cg, "XOR R1, R6");
+            emit_line(cg, "POP R6");
+        }
+        emit_line(cg, "CMP R0, R1");
+    }
+}
+
+// Emit code that jumps to target_label when the condition is FALSE.
+// For comparison nodes, this fuses the comparison with the conditional jump,
+// avoiding the overhead of materializing a boolean into R0.
+static void emit_branch_false(SeCodegen* cg, AstNode* cond, int target_label) {
+    if (cg->has_error) return;
+    if (!cond) return;
+
+    // Skip 16-bit comparisons for now (rare in conditions, complex fusion)
+    bool is_16 = false;
+
+    switch (cond->kind) {
+    case AST_EQ:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JNZ __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_NE:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JZ __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_LT:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JNC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_GE:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_GT:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            // Swap operands: CMP b,a; JNC (false when a<=b)
+            emit_cmp_operands(cg, cond, true);
+            emit_line(cg, "JNC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_LE:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            // Swap operands: CMP b,a; JC (false when a>b)
+            emit_cmp_operands(cg, cond, true);
+            emit_line(cg, "JC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_LOGIC_AND:
+        // (and a b): false if a is false OR b is false
+        emit_branch_false(cg, cond->as.binary.left, target_label);
+        emit_branch_false(cg, cond->as.binary.right, target_label);
+        return;
+    case AST_LOGIC_NOT:
+        // (not x): false when x is true
+        emit_expr(cg, cond->as.unary.operand);
+        emit_line(cg, "JTRUE __L%d", target_label);
+        return;
+    case AST_NILP:
+        // (nil? x): false when x != 0xFF
+        emit_expr(cg, cond->as.unary.operand);
+        emit_line(cg, "LOADI R1, 0xFF");
+        emit_line(cg, "CMP R0, R1");
+        emit_line(cg, "JNZ __L%d", target_label);
+        return;
+    case AST_ZEROP:
+        // (zero? x): false when x != 0
+        emit_expr(cg, cond->as.unary.operand);
+        emit_line(cg, "OR R0, R0");
+        emit_line(cg, "JNZ __L%d", target_label);
+        return;
+    case AST_TRUE:
+        // Always true, never branch
+        return;
+    case AST_FALSE:
+    case AST_NIL:
+        // Always false, always branch
+        emit_line(cg, "JMP __L%d", target_label);
+        return;
+    default:
+        break;
+    }
+    // Fallback: evaluate expression and use JFALSE macro
+    emit_expr(cg, cond);
+    emit_line(cg, "JFALSE __L%d", target_label);
+}
+
+// Emit code that jumps to target_label when the condition is TRUE.
+static void emit_branch_true(SeCodegen* cg, AstNode* cond, int target_label) {
+    if (cg->has_error) return;
+    if (!cond) return;
+
+    bool is_16 = false;
+
+    switch (cond->kind) {
+    case AST_EQ:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JZ __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_NE:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JNZ __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_LT:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_GE:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, false);
+            emit_line(cg, "JNC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_GT:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, true);
+            emit_line(cg, "JC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_LE:
+        is_16 = expr_is_16bit(cg, cond->as.binary.left) || expr_is_16bit(cg, cond->as.binary.right);
+        if (!is_16) {
+            emit_cmp_operands(cg, cond, true);
+            emit_line(cg, "JNC __L%d", target_label);
+            return;
+        }
+        break;
+    case AST_LOGIC_OR:
+        // (or a b): true if a is true OR b is true
+        emit_branch_true(cg, cond->as.binary.left, target_label);
+        emit_branch_true(cg, cond->as.binary.right, target_label);
+        return;
+    case AST_LOGIC_NOT:
+        // (not x): true when x is false
+        emit_expr(cg, cond->as.unary.operand);
+        emit_line(cg, "JFALSE __L%d", target_label);
+        return;
+    case AST_TRUE:
+        emit_line(cg, "JMP __L%d", target_label);
+        return;
+    case AST_FALSE:
+    case AST_NIL:
+        return;
+    default:
+        break;
+    }
+    // Fallback: evaluate expression and use JTRUE macro
+    emit_expr(cg, cond);
+    emit_line(cg, "JTRUE __L%d", target_label);
+}
+
 static void emit_expr(SeCodegen* cg, AstNode* node) {
     if (cg->has_error) return;
 
@@ -1196,6 +1470,21 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     }
 
     case AST_ADD:
+        // 8-bit optimized path: avoid PUSH/POP when one operand is simple
+        if (!expr_is_16bit(cg, node->as.binary.left) && !expr_is_16bit(cg, node->as.binary.right)) {
+            if (is_simple_operand(cg, node->as.binary.right)) {
+                emit_expr(cg, node->as.binary.left);
+                emit_simple_to_reg(cg, node->as.binary.right, "R1");
+                emit_line(cg, "ADD R0, R1");
+                break;
+            }
+            if (is_simple_operand(cg, node->as.binary.left)) {
+                emit_expr(cg, node->as.binary.right);
+                emit_simple_to_reg(cg, node->as.binary.left, "R1");
+                emit_line(cg, "ADD R0, R1"); // commutative
+                break;
+            }
+        }
         if (expr_is_16bit(cg, node->as.binary.left) || expr_is_16bit(cg, node->as.binary.right)) {
             // 16-bit addition: R0:R1 = left + right using ADD (low) + ADC (high)
             emit_expr(cg, node->as.binary.left);
@@ -1234,6 +1523,15 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
         break;
 
     case AST_SUB:
+        // 8-bit optimized path: avoid PUSH/POP when right operand is simple
+        if (!expr_is_16bit(cg, node->as.binary.left) && !expr_is_16bit(cg, node->as.binary.right)) {
+            if (is_simple_operand(cg, node->as.binary.right)) {
+                emit_expr(cg, node->as.binary.left);
+                emit_simple_to_reg(cg, node->as.binary.right, "R1");
+                emit_line(cg, "SUB R0, R1");
+                break;
+            }
+        }
         if (expr_is_16bit(cg, node->as.binary.left) || expr_is_16bit(cg, node->as.binary.right)) {
             // 16-bit subtraction: R0:R1 = left - right using SUB (low) + SBC (high)
             emit_expr(cg, node->as.binary.left);
@@ -1288,34 +1586,59 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
         break;
 
     case AST_BAND:
-        emit_expr(cg, node->as.binary.left);
-        emit_line(cg, "PUSH R0");
-        emit_expr(cg, node->as.binary.right);
-        emit_line(cg, "MOV R1, R0");
-        emit_line(cg, "POP R0");
+        if (is_simple_operand(cg, node->as.binary.right)) {
+            emit_expr(cg, node->as.binary.left);
+            emit_simple_to_reg(cg, node->as.binary.right, "R1");
+        } else if (is_simple_operand(cg, node->as.binary.left)) {
+            emit_expr(cg, node->as.binary.right);
+            emit_simple_to_reg(cg, node->as.binary.left, "R1");
+        } else {
+            emit_expr(cg, node->as.binary.left);
+            emit_line(cg, "PUSH R0");
+            emit_expr(cg, node->as.binary.right);
+            emit_line(cg, "MOV R1, R0");
+            emit_line(cg, "POP R0");
+        }
         emit_line(cg, "AND R0, R1");
         break;
 
     case AST_BOR:
-        emit_expr(cg, node->as.binary.left);
-        emit_line(cg, "PUSH R0");
-        emit_expr(cg, node->as.binary.right);
-        emit_line(cg, "MOV R1, R0");
-        emit_line(cg, "POP R0");
+        if (is_simple_operand(cg, node->as.binary.right)) {
+            emit_expr(cg, node->as.binary.left);
+            emit_simple_to_reg(cg, node->as.binary.right, "R1");
+        } else if (is_simple_operand(cg, node->as.binary.left)) {
+            emit_expr(cg, node->as.binary.right);
+            emit_simple_to_reg(cg, node->as.binary.left, "R1");
+        } else {
+            emit_expr(cg, node->as.binary.left);
+            emit_line(cg, "PUSH R0");
+            emit_expr(cg, node->as.binary.right);
+            emit_line(cg, "MOV R1, R0");
+            emit_line(cg, "POP R0");
+        }
         emit_line(cg, "OR R0, R1");
         break;
 
     case AST_XOR:
-        emit_expr(cg, node->as.binary.left);
-        emit_line(cg, "PUSH R0");
-        emit_expr(cg, node->as.binary.right);
-        emit_line(cg, "MOV R1, R0");
-        emit_line(cg, "POP R0");
+        if (is_simple_operand(cg, node->as.binary.right)) {
+            emit_expr(cg, node->as.binary.left);
+            emit_simple_to_reg(cg, node->as.binary.right, "R1");
+        } else if (is_simple_operand(cg, node->as.binary.left)) {
+            emit_expr(cg, node->as.binary.right);
+            emit_simple_to_reg(cg, node->as.binary.left, "R1");
+        } else {
+            emit_expr(cg, node->as.binary.left);
+            emit_line(cg, "PUSH R0");
+            emit_expr(cg, node->as.binary.right);
+            emit_line(cg, "MOV R1, R0");
+            emit_line(cg, "POP R0");
+        }
         emit_line(cg, "XOR R0, R1");
         break;
 
     case AST_BNOT:
         emit_expr(cg, node->as.unary.operand);
+        // XOR with 0xFF to flip all bits
         emit_line(cg, "LOADI R1, 0xFF");
         emit_line(cg, "XOR R0, R1");
         break;
@@ -1480,92 +1803,55 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     }
 
     case AST_EQ: {
-        int32_t const_val;
+        int lbl_true = new_label(cg);
+        int lbl_end = new_label(cg);
         if (!expr_is_16bit(cg, node->as.binary.left) &&
-            eval_const(cg, node->as.binary.right, &const_val)) {
-            int lbl_true = new_label(cg);
-            int lbl_end = new_label(cg);
-            emit_expr(cg, node->as.binary.left);
-            emit_line(cg, "LOADI R1, 0x%02X", const_val & 0xFF);
-            emit_line(cg, "CMP R0, R1");
-            emit_line(cg, "JZ __L%d", lbl_true);
-            emit_line(cg, "LOADI R0, 0");
-            emit_line(cg, "JMP __L%d", lbl_end);
-            emit(cg, "__L%d:\n", lbl_true);
-            emit_line(cg, "LOADI R0, 1");
-            emit(cg, "__L%d:\n", lbl_end);
+            !expr_is_16bit(cg, node->as.binary.right)) {
+            emit_cmp_operands(cg, node, false);
         } else {
-            int lbl_true = new_label(cg);
-            int lbl_end = new_label(cg);
             emit_expr(cg, node->as.binary.left);
             emit_line(cg, "PUSH R0");
             emit_expr(cg, node->as.binary.right);
             emit_line(cg, "MOV R1, R0");
             emit_line(cg, "POP R0");
             emit_line(cg, "CMP R0, R1");
-            emit_line(cg, "JZ __L%d", lbl_true);
-            emit_line(cg, "LOADI R0, 0");
-            emit_line(cg, "JMP __L%d", lbl_end);
-            emit(cg, "__L%d:\n", lbl_true);
-            emit_line(cg, "LOADI R0, 1");
-            emit(cg, "__L%d:\n", lbl_end);
         }
+        emit_line(cg, "JZ __L%d", lbl_true);
+        emit_line(cg, "LOADI R0, 0");
+        emit_line(cg, "JMP __L%d", lbl_end);
+        emit(cg, "__L%d:\n", lbl_true);
+        emit_line(cg, "LOADI R0, 1");
+        emit(cg, "__L%d:\n", lbl_end);
         break;
     }
 
     case AST_NE: {
-        int32_t const_val;
+        int lbl_true = new_label(cg);
+        int lbl_end = new_label(cg);
         if (!expr_is_16bit(cg, node->as.binary.left) &&
-            eval_const(cg, node->as.binary.right, &const_val)) {
-            int lbl_true = new_label(cg);
-            int lbl_end = new_label(cg);
-            emit_expr(cg, node->as.binary.left);
-            emit_line(cg, "LOADI R1, 0x%02X", const_val & 0xFF);
-            emit_line(cg, "CMP R0, R1");
-            emit_line(cg, "JNZ __L%d", lbl_true);
-            emit_line(cg, "LOADI R0, 0");
-            emit_line(cg, "JMP __L%d", lbl_end);
-            emit(cg, "__L%d:\n", lbl_true);
-            emit_line(cg, "LOADI R0, 1");
-            emit(cg, "__L%d:\n", lbl_end);
+            !expr_is_16bit(cg, node->as.binary.right)) {
+            emit_cmp_operands(cg, node, false);
         } else {
-            int lbl_true = new_label(cg);
-            int lbl_end = new_label(cg);
             emit_expr(cg, node->as.binary.left);
             emit_line(cg, "PUSH R0");
             emit_expr(cg, node->as.binary.right);
             emit_line(cg, "MOV R1, R0");
             emit_line(cg, "POP R0");
             emit_line(cg, "CMP R0, R1");
-            emit_line(cg, "JNZ __L%d", lbl_true);
-            emit_line(cg, "LOADI R0, 0");
-            emit_line(cg, "JMP __L%d", lbl_end);
-            emit(cg, "__L%d:\n", lbl_true);
-            emit_line(cg, "LOADI R0, 1");
-            emit(cg, "__L%d:\n", lbl_end);
         }
+        emit_line(cg, "JNZ __L%d", lbl_true);
+        emit_line(cg, "LOADI R0, 0");
+        emit_line(cg, "JMP __L%d", lbl_end);
+        emit(cg, "__L%d:\n", lbl_true);
+        emit_line(cg, "LOADI R0, 1");
+        emit(cg, "__L%d:\n", lbl_end);
         break;
     }
 
     case AST_LT: {
         int lbl_true = new_label(cg);
         int lbl_end = new_label(cg);
-        bool is_sgn =
-            expr_is_signed(cg, node->as.binary.left) || expr_is_signed(cg, node->as.binary.right);
-        emit_expr(cg, node->as.binary.left);
-        emit_line(cg, "PUSH R0");
-        emit_expr(cg, node->as.binary.right);
-        emit_line(cg, "MOV R1, R0");
-        emit_line(cg, "POP R0");
-        if (is_sgn) {
-            // Signed comparison: XOR both with 0x80 to map signed order to unsigned
-            emit_line(cg, "PUSH R6");
-            emit_line(cg, "LOADI R6, 0x80");
-            emit_line(cg, "XOR R0, R6");
-            emit_line(cg, "XOR R1, R6");
-            emit_line(cg, "POP R6");
-        }
-        emit_line(cg, "CMP R0, R1");
+        emit_cmp_operands(cg, node, false);
         emit_line(cg, "JC __L%d", lbl_true);
         emit_line(cg, "LOADI R0, 0");
         emit_line(cg, "JMP __L%d", lbl_end);
@@ -1576,24 +1862,10 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     }
 
     case AST_GT: {
-        // a > b means b < a, so swap and use JC
+        // a > b: swap operands, CMP b,a, then C=1 means b<a (=a>b)
         int lbl_true = new_label(cg);
         int lbl_end = new_label(cg);
-        bool is_sgn =
-            expr_is_signed(cg, node->as.binary.left) || expr_is_signed(cg, node->as.binary.right);
-        emit_expr(cg, node->as.binary.right); // eval b first
-        emit_line(cg, "PUSH R0");
-        emit_expr(cg, node->as.binary.left); // eval a
-        emit_line(cg, "MOV R1, R0");
-        emit_line(cg, "POP R0");
-        if (is_sgn) {
-            emit_line(cg, "PUSH R6");
-            emit_line(cg, "LOADI R6, 0x80");
-            emit_line(cg, "XOR R0, R6");
-            emit_line(cg, "XOR R1, R6");
-            emit_line(cg, "POP R6");
-        }
-        emit_line(cg, "CMP R0, R1"); // b - a, C if b < a
+        emit_cmp_operands(cg, node, true);
         emit_line(cg, "JC __L%d", lbl_true);
         emit_line(cg, "LOADI R0, 0");
         emit_line(cg, "JMP __L%d", lbl_end);
@@ -1604,27 +1876,11 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     }
 
     case AST_LE: {
-        // a <= b means NOT (a > b) means NOT (b < a)
+        // a <= b: swap -> CMP b,a, JNC (true when b >= a = a <= b)
         int lbl_true = new_label(cg);
         int lbl_end = new_label(cg);
-        bool is_sgn =
-            expr_is_signed(cg, node->as.binary.left) || expr_is_signed(cg, node->as.binary.right);
-        emit_expr(cg, node->as.binary.left);
-        emit_line(cg, "PUSH R0");
-        emit_expr(cg, node->as.binary.right);
-        emit_line(cg, "MOV R1, R0");
-        emit_line(cg, "POP R0");
-        if (is_sgn) {
-            emit_line(cg, "PUSH R6");
-            emit_line(cg, "LOADI R6, 0x80");
-            emit_line(cg, "XOR R0, R6");
-            emit_line(cg, "XOR R1, R6");
-            emit_line(cg, "POP R6");
-        }
-        emit_line(cg, "CMP R0, R1");
-        // C or Z means <=
-        emit_line(cg, "JC __L%d", lbl_true);
-        emit_line(cg, "JZ __L%d", lbl_true);
+        emit_cmp_operands(cg, node, true);
+        emit_line(cg, "JNC __L%d", lbl_true);
         emit_line(cg, "LOADI R0, 0");
         emit_line(cg, "JMP __L%d", lbl_end);
         emit(cg, "__L%d:\n", lbl_true);
@@ -1634,25 +1890,11 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     }
 
     case AST_GE: {
-        // a >= b means NOT (a < b)
+        // a >= b: CMP a,b, JNC (true when a >= b, no carry)
         int lbl_true = new_label(cg);
         int lbl_end = new_label(cg);
-        bool is_sgn =
-            expr_is_signed(cg, node->as.binary.left) || expr_is_signed(cg, node->as.binary.right);
-        emit_expr(cg, node->as.binary.left);
-        emit_line(cg, "PUSH R0");
-        emit_expr(cg, node->as.binary.right);
-        emit_line(cg, "MOV R1, R0");
-        emit_line(cg, "POP R0");
-        if (is_sgn) {
-            emit_line(cg, "PUSH R6");
-            emit_line(cg, "LOADI R6, 0x80");
-            emit_line(cg, "XOR R0, R6");
-            emit_line(cg, "XOR R1, R6");
-            emit_line(cg, "POP R6");
-        }
-        emit_line(cg, "CMP R0, R1");
-        emit_line(cg, "JNC __L%d", lbl_true); // no carry = >=
+        emit_cmp_operands(cg, node, false);
+        emit_line(cg, "JNC __L%d", lbl_true);
         emit_line(cg, "LOADI R0, 0");
         emit_line(cg, "JMP __L%d", lbl_end);
         emit(cg, "__L%d:\n", lbl_true);
@@ -1808,21 +2050,22 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
                     set_error(cg, node->line, "cannot resolve record address");
                     break;
                 }
-                emit_expr(cg, node->as.set.value);
-                emit_line(cg, "PUSH R0");
-                if (field->is_16bit) {
-                    emit_line(cg, "PUSH R1");
-                }
-                emit_line(cg, "LOADI R6, 0x%02X", (addr >> 8) & 0xFF);
-                emit_line(cg, "LOADI R7, 0x%02X", addr & 0xFF);
-                if (field->is_16bit) {
-                    emit_line(cg, "POP R1");
-                    emit_line(cg, "POP R0");
+                if (!field->is_16bit && is_simple_operand(cg, node->as.set.value)) {
+                    // Optimized: set up address first, then load value
+                    emit_line(cg, "LOADI R6, 0x%02X", (addr >> 8) & 0xFF);
+                    emit_line(cg, "LOADI R7, 0x%02X", addr & 0xFF);
+                    emit_expr(cg, node->as.set.value);
                     emit_line(cg, "STORE R0, [R6:R7 + %d]", field->offset);
-                    emit_line(cg, "STORE R1, [R6:R7 + %d]", field->offset + 1);
                 } else {
-                    emit_line(cg, "POP R0");
-                    emit_line(cg, "STORE R0, [R6:R7 + %d]", field->offset);
+                    emit_expr(cg, node->as.set.value);
+                    emit_line(cg, "LOADI R6, 0x%02X", (addr >> 8) & 0xFF);
+                    emit_line(cg, "LOADI R7, 0x%02X", addr & 0xFF);
+                    if (field->is_16bit) {
+                        emit_line(cg, "STORE R0, [R6:R7 + %d]", field->offset);
+                        emit_line(cg, "STORE R1, [R6:R7 + %d]", field->offset + 1);
+                    } else {
+                        emit_line(cg, "STORE R0, [R6:R7 + %d]", field->offset);
+                    }
                 }
             } else if (node->as.set.target_expr->kind == AST_NTH) {
                 // (set! (:field (nth arr i)) value) - field of array element
@@ -1966,7 +2209,6 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
                 break;
             }
 
-            emit_expr(cg, node->as.set.value);
             int32_t addr;
             if (!is_data_label(cg, node->as.set.var, &addr)) {
                 set_error(cg, node->line, "set!: target must be a var");
@@ -1978,16 +2220,24 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
             if (label && label->size == 2 && label->element_count == 0 &&
                 label->record_type[0] == '\0') {
                 // 16-bit variable: R0 = hi, R1 = lo
+                emit_expr(cg, node->as.set.value);
                 emit_line(cg, "LOADI R6, 0x%02X", (addr >> 8) & 0xFF);
                 emit_line(cg, "LOADI R7, 0x%02X", addr & 0xFF);
                 emit_line(cg, "STORE R0, [R6:R7]+"); // hi byte, auto-increment
                 emit_line(cg, "STORE R1, [R6:R7]");  // lo byte
             } else {
-                emit_line(cg, "PUSH R0");
-                emit_line(cg, "LOADI R6, 0x%02X", (addr >> 8) & 0xFF);
-                emit_line(cg, "LOADI R7, 0x%02X", addr & 0xFF);
-                emit_line(cg, "POP R0");
-                emit_line(cg, "STORE R0, [R6:R7]");
+                // For simple values, avoid PUSH/POP: set up addr first, then eval
+                if (is_simple_operand(cg, node->as.set.value)) {
+                    emit_line(cg, "LOADI R6, 0x%02X", (addr >> 8) & 0xFF);
+                    emit_line(cg, "LOADI R7, 0x%02X", addr & 0xFF);
+                    emit_expr(cg, node->as.set.value);
+                    emit_line(cg, "STORE R0, [R6:R7]");
+                } else {
+                    emit_expr(cg, node->as.set.value);
+                    emit_line(cg, "LOADI R6, 0x%02X", (addr >> 8) & 0xFF);
+                    emit_line(cg, "LOADI R7, 0x%02X", addr & 0xFF);
+                    emit_line(cg, "STORE R0, [R6:R7]");
+                }
             }
         }
         break;
@@ -1997,8 +2247,7 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
         int lbl_else = new_label(cg);
         int lbl_end = new_label(cg);
 
-        emit_expr(cg, node->as.if_expr.cond);
-        emit_line(cg, "JFALSE __L%d", lbl_else);
+        emit_branch_false(cg, node->as.if_expr.cond, lbl_else);
 
         emit_expr(cg, node->as.if_expr.then_branch);
         emit_line(cg, "JMP __L%d", lbl_end);
@@ -2015,8 +2264,7 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
         int lbl_end = new_label(cg);
 
         emit(cg, "__L%d:\n", lbl_loop);
-        emit_expr(cg, node->as.while_expr.cond);
-        emit_line(cg, "JFALSE __L%d", lbl_end);
+        emit_branch_false(cg, node->as.while_expr.cond, lbl_end);
 
         for (size_t i = 0; i < node->as.while_expr.body.count; i++) {
             emit_expr(cg, node->as.while_expr.body.items[i]);
@@ -2086,8 +2334,7 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
             int lbl_end = new_label(cg);
             for (size_t i = 0; i < n; i++) {
                 int lbl_next = new_label(cg);
-                emit_expr(cg, node->as.cond.tests[i]);
-                emit_line(cg, "JFALSE __L%d", lbl_next);
+                emit_branch_false(cg, node->as.cond.tests[i], lbl_next);
                 for (size_t j = 0; j < node->as.cond.bodies[i].count; j++) {
                     emit_expr(cg, node->as.cond.bodies[i].items[j]);
                 }
@@ -2101,26 +2348,8 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     }
 
     case AST_WHEN: {
-        AstNode* cond = node->as.when_expr.cond;
-        int32_t when_const;
-        bool when_eq_const =
-            (cond && cond->kind == AST_EQ && cond->as.binary.left &&
-             cond->as.binary.left->kind == AST_SYMBOL && !expr_is_16bit(cg, cond->as.binary.left) &&
-             eval_const(cg, cond->as.binary.right, &when_const));
         int lbl_end = new_label(cg);
-        int lbl_body = new_label(cg);
-        if (when_eq_const) {
-            emit_expr(cg, cond->as.binary.left);
-            emit_line(cg, "LOADI R1, 0x%02X", when_const & 0xFF);
-            emit_line(cg, "CMP R0, R1");
-            emit_line(cg, "JZ __L%d", lbl_body);
-        } else {
-            emit_expr(cg, cond);
-            emit_line(cg, "JTRUE __L%d", lbl_body);
-        }
-        emit_line(cg, "LOADI R0, 0xFF");
-        emit_line(cg, "JMP __L%d", lbl_end);
-        emit(cg, "__L%d:\n", lbl_body);
+        emit_branch_false(cg, node->as.when_expr.cond, lbl_end);
         for (size_t i = 0; i < node->as.when_expr.body.count; i++) {
             emit_expr(cg, node->as.when_expr.body.items[i]);
         }
@@ -2129,26 +2358,9 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     }
 
     case AST_UNLESS: {
-        AstNode* cond = node->as.when_expr.cond;
-        int32_t unless_const;
-        bool unless_eq_const =
-            (cond && cond->kind == AST_EQ && cond->as.binary.left &&
-             cond->as.binary.left->kind == AST_SYMBOL && !expr_is_16bit(cg, cond->as.binary.left) &&
-             eval_const(cg, cond->as.binary.right, &unless_const));
         int lbl_end = new_label(cg);
-        int lbl_body = new_label(cg);
-        if (unless_eq_const) {
-            emit_expr(cg, cond->as.binary.left);
-            emit_line(cg, "LOADI R1, 0x%02X", unless_const & 0xFF);
-            emit_line(cg, "CMP R0, R1");
-            emit_line(cg, "JNZ __L%d", lbl_body);
-        } else {
-            emit_expr(cg, cond);
-            emit_line(cg, "JFALSE __L%d", lbl_body);
-        }
-        emit_line(cg, "LOADI R0, 0xFF");
-        emit_line(cg, "JMP __L%d", lbl_end);
-        emit(cg, "__L%d:\n", lbl_body);
+        // Unless = when NOT cond, so branch TRUE to skip body
+        emit_branch_true(cg, node->as.when_expr.cond, lbl_end);
         for (size_t i = 0; i < node->as.when_expr.body.count; i++) {
             emit_expr(cg, node->as.when_expr.body.items[i]);
         }
@@ -2317,8 +2529,7 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
             emit_line(cg, "JNC __L%d", lbl_done);
         }
         if (node->as.for_expr.when_cond) {
-            emit_expr(cg, node->as.for_expr.when_cond);
-            emit_line(cg, "JFALSE __L%d", lbl_continue);
+            emit_branch_false(cg, node->as.for_expr.when_cond, lbl_continue);
         }
         for (size_t i = 0; i < node->as.for_expr.body.count; i++) {
             emit_expr(cg, node->as.for_expr.body.items[i]);
@@ -2431,10 +2642,14 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
 
     case AST_CALL: {
         bool direct = is_function(cg, node->as.call.func);
+        bool save_let_base = (cg->let_depth > 0);
 
-        // Save R2:R3 (let-local base) and R4:R5 (frame pointer) before call
-        emit_line(cg, "PUSH R2");
-        emit_line(cg, "PUSH R3");
+        // Save R2:R3 (let-local base) only when inside a let scope
+        if (save_let_base) {
+            emit_line(cg, "PUSH R2");
+            emit_line(cg, "PUSH R3");
+        }
+        // Always save R4:R5 (frame pointer) - callee will set FP
         emit_line(cg, "PUSH R4");
         emit_line(cg, "PUSH R5");
 
@@ -2510,8 +2725,10 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
         // Restore R4:R5 and R2:R3
         emit_line(cg, "POP R5");
         emit_line(cg, "POP R4");
-        emit_line(cg, "POP R3");
-        emit_line(cg, "POP R2");
+        if (save_let_base) {
+            emit_line(cg, "POP R3");
+            emit_line(cg, "POP R2");
+        }
         break;
     }
 
@@ -2698,11 +2915,14 @@ static void emit_expr(SeCodegen* cg, AstNode* node) {
     case AST_CAST_U8:
     case AST_CAST_I8:
         // (u8 expr) / (i8 expr) - truncate to 8-bit
-        // Currently a no-op since all values are 8-bit, but explicitly masks
-        // to ensure correctness when 16-bit operations are added
         emit_expr(cg, node->as.unary.operand);
-        emit_line(cg, "LOADI R1, 0xFF");
-        emit_line(cg, "AND R0, R1");
+        // Only mask if the operand is 16-bit (cast is truncation)
+        // For 8-bit operands, this is already a no-op
+        if (expr_is_16bit(cg, node->as.unary.operand)) {
+            // R0 already has the high byte from 16-bit expression,
+            // but for cast, we want just the low byte (R1 for 16-bit results)
+            emit_line(cg, "MOV R0, R1");
+        }
         break;
 
     case AST_FN: {
diff --git a/sec/optimizer.c b/sec/optimizer.c
index 2ff5b13..5115ac2 100644
--- a/sec/optimizer.c
+++ b/sec/optimizer.c
@@ -146,6 +146,22 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number + node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (+ x 0) -> x, (+ 0 x) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return node->as.binary.left;
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 0)
+            return node->as.binary.right;
+        // Strength: (+ x 1) -> (inc x), (+ 1 x) -> (inc x)
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 1) {
+            node->kind = AST_INC;
+            node->as.unary.operand = node->as.binary.left;
+            return node;
+        }
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 1) {
+            node->kind = AST_INC;
+            node->as.unary.operand = node->as.binary.right;
+            return node;
+        }
         break;
     case AST_SUB:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right)) {
@@ -153,6 +169,15 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number - node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (- x 0) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return node->as.binary.left;
+        // Strength: (- x 1) -> (dec x)
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 1) {
+            node->kind = AST_DEC;
+            node->as.unary.operand = node->as.binary.left;
+            return node;
+        }
         break;
     case AST_MUL:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right)) {
@@ -160,6 +185,16 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number * node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (* x 1) -> x, (* 1 x) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 1)
+            return node->as.binary.left;
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 1)
+            return node->as.binary.right;
+        // Annihilation: (* x 0) -> 0, (* 0 x) -> 0
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return make_number(pool, 0, node->line, node->column);
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 0)
+            return make_number(pool, 0, node->line, node->column);
         break;
     case AST_DIV:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right) &&
@@ -168,6 +203,9 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number / node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (/ x 1) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 1)
+            return node->as.binary.left;
         break;
     case AST_MOD:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right) &&
@@ -183,6 +221,16 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number & node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (& x 0xFF) -> x (for u8, mask is noop)
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0xFF)
+            return node->as.binary.left;
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 0xFF)
+            return node->as.binary.right;
+        // Annihilation: (& x 0) -> 0
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return make_number(pool, 0, node->line, node->column);
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 0)
+            return make_number(pool, 0, node->line, node->column);
         break;
     case AST_BOR:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right)) {
@@ -190,6 +238,11 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number | node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (| x 0) -> x, (| 0 x) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return node->as.binary.left;
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 0)
+            return node->as.binary.right;
         break;
     case AST_XOR:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right)) {
@@ -197,6 +250,11 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number ^ node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (^ x 0) -> x, (^ 0 x) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return node->as.binary.left;
+        if (is_const_number(node->as.binary.left) && node->as.binary.left->as.number == 0)
+            return node->as.binary.right;
         break;
     case AST_SHL:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right)) {
@@ -204,6 +262,9 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number << node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (<< x 0) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return node->as.binary.left;
         break;
     case AST_SHR:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right)) {
@@ -211,6 +272,9 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
                                node->as.binary.left->as.number >> node->as.binary.right->as.number,
                                node->line, node->column);
         }
+        // Identity: (>> x 0) -> x
+        if (is_const_number(node->as.binary.right) && node->as.binary.right->as.number == 0)
+            return node->as.binary.left;
         break;
     case AST_EQ:
         if (is_const_number(node->as.binary.left) && is_const_number(node->as.binary.right)) {
@@ -294,12 +358,18 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
             return make_number(pool, node->as.unary.operand->as.number & 0xFF, node->line,
                                node->column);
         }
+        // Redundant cast: (u8 (u8 x)) -> (u8 x)
+        if (node->as.unary.operand->kind == AST_CAST_U8)
+            return node->as.unary.operand;
         break;
     case AST_CAST_I8:
         if (is_const_number(node->as.unary.operand)) {
             int8_t v = (int8_t)(node->as.unary.operand->as.number & 0xFF);
             return make_number(pool, (int32_t)v, node->line, node->column);
         }
+        // Redundant cast: (i8 (i8 x)) -> (i8 x)
+        if (node->as.unary.operand->kind == AST_CAST_I8)
+            return node->as.unary.operand;
         break;
     case AST_IF:
         // Fold constant conditions
@@ -313,6 +383,64 @@ static AstNode* fold_node(AstPool* pool, AstNode* node) {
         if (node->as.if_expr.cond->kind == AST_TRUE) return node->as.if_expr.then_branch;
         if (node->as.if_expr.cond->kind == AST_FALSE) return node->as.if_expr.else_branch;
         break;
+    case AST_WHEN:
+        // (when true body...) -> (do body...)
+        if (node->as.when_expr.cond->kind == AST_TRUE ||
+            (is_const_number(node->as.when_expr.cond) &&
+             node->as.when_expr.cond->as.number != 0)) {
+            if (node->as.when_expr.body.count == 1)
+                return node->as.when_expr.body.items[0];
+            node->kind = AST_DO;
+            node->as.block.exprs = node->as.when_expr.body;
+            return node;
+        }
+        // (when false body...) -> nil
+        if (node->as.when_expr.cond->kind == AST_FALSE ||
+            (is_const_number(node->as.when_expr.cond) &&
+             node->as.when_expr.cond->as.number == 0)) {
+            AstNode* nil = ast_alloc(pool);
+            if (nil) { nil->kind = AST_NIL; nil->line = node->line; nil->column = node->column; }
+            return nil;
+        }
+        break;
+    case AST_UNLESS:
+        // (unless false body...) -> (do body...)
+        if (node->as.when_expr.cond->kind == AST_FALSE ||
+            (is_const_number(node->as.when_expr.cond) &&
+             node->as.when_expr.cond->as.number == 0)) {
+            if (node->as.when_expr.body.count == 1)
+                return node->as.when_expr.body.items[0];
+            node->kind = AST_DO;
+            node->as.block.exprs = node->as.when_expr.body;
+            return node;
+        }
+        // (unless true body...) -> nil
+        if (node->as.when_expr.cond->kind == AST_TRUE ||
+            (is_const_number(node->as.when_expr.cond) &&
+             node->as.when_expr.cond->as.number != 0)) {
+            AstNode* nil = ast_alloc(pool);
+            if (nil) { nil->kind = AST_NIL; nil->line = node->line; nil->column = node->column; }
+            return nil;
+        }
+        break;
+    case AST_LOGIC_NOT:
+        // (not true) -> false, (not false) -> true
+        if (node->as.unary.operand->kind == AST_TRUE) {
+            node->kind = AST_FALSE;
+            return node;
+        }
+        if (node->as.unary.operand->kind == AST_FALSE) {
+            node->kind = AST_TRUE;
+            return node;
+        }
+        if (is_const_number(node->as.unary.operand)) {
+            return make_number(pool, node->as.unary.operand->as.number == 0 ? 1 : 0,
+                               node->line, node->column);
+        }
+        // (not (not x)) -> x (double negation elimination)
+        if (node->as.unary.operand->kind == AST_LOGIC_NOT)
+            return node->as.unary.operand->as.unary.operand;
+        break;
     default: break;
     }
 
@@ -464,6 +592,42 @@ static AstNode* strength_node(AstPool* pool, AstNode* node) {
         }
     }
 
+    // Strength reduce: (/ x 2^n) -> (>> x n)
+    if (node->kind == AST_DIV && is_const_number(node->as.binary.right)) {
+        int shift = log2_exact(node->as.binary.right->as.number);
+        if (shift > 0) {
+            AstNode* shift_node = make_number(pool, shift, node->line, node->column);
+            if (shift_node) {
+                node->kind = AST_SHR;
+                node->as.binary.right = shift_node;
+            }
+        }
+    }
+
+    // Strength reduce: (% x 2^n) -> (& x (2^n - 1))
+    if (node->kind == AST_MOD && is_const_number(node->as.binary.right)) {
+        int shift = log2_exact(node->as.binary.right->as.number);
+        if (shift > 0) {
+            int32_t mask = node->as.binary.right->as.number - 1;
+            AstNode* mask_node = make_number(pool, mask, node->line, node->column);
+            if (mask_node) {
+                node->kind = AST_BAND;
+                node->as.binary.right = mask_node;
+            }
+        }
+    }
+
+    // Strength reduce: (+ x x) -> (<< x 1)
+    if (node->kind == AST_ADD && node->as.binary.left && node->as.binary.right &&
+        node->as.binary.left->kind == AST_SYMBOL && node->as.binary.right->kind == AST_SYMBOL &&
+        strcmp(node->as.binary.left->as.symbol.name, node->as.binary.right->as.symbol.name) == 0) {
+        AstNode* one = make_number(pool, 1, node->line, node->column);
+        if (one) {
+            node->kind = AST_SHL;
+            node->as.binary.right = one;
+        }
+    }
+
     return node;
 }
 
@@ -1248,6 +1412,335 @@ static void pass_dead_fn_elim(AstProgram* program) {
     program->node_count = write;
 }
 
+// -------------------------------------------------------------------
+// Function inlining – inline small leaf functions at call sites
+// -------------------------------------------------------------------
+
+// Count AST nodes in a subtree (rough size metric)
+static int count_nodes(AstNode* node) {
+    if (!node) return 0;
+    switch (node->kind) {
+    case AST_ADD: case AST_SUB: case AST_MUL: case AST_DIV: case AST_MOD:
+    case AST_BAND: case AST_BOR: case AST_XOR: case AST_SHL: case AST_SHR:
+    case AST_EQ: case AST_NE: case AST_LT: case AST_GT: case AST_LE: case AST_GE:
+    case AST_LOGIC_AND: case AST_LOGIC_OR: case AST_NTH:
+        return 1 + count_nodes(node->as.binary.left) + count_nodes(node->as.binary.right);
+    case AST_NEG: case AST_INC: case AST_DEC: case AST_BNOT: case AST_LNOT:
+    case AST_LOGIC_NOT: case AST_HI: case AST_LO: case AST_LEN:
+    case AST_NILP: case AST_ZEROP: case AST_POSP: case AST_NEGP:
+    case AST_CAST_U8: case AST_CAST_I8:
+        return 1 + count_nodes(node->as.unary.operand);
+    case AST_IF:
+        return 1 + count_nodes(node->as.if_expr.cond) +
+               count_nodes(node->as.if_expr.then_branch) +
+               count_nodes(node->as.if_expr.else_branch);
+    case AST_CALL: {
+        int c = 1;
+        for (size_t i = 0; i < node->as.call.arg_count; i++)
+            c += count_nodes(node->as.call.args[i]);
+        return c;
+    }
+    case AST_LOAD: return 1 + count_nodes(node->as.load.addr);
+    case AST_STORE: return 1 + count_nodes(node->as.store.addr) + count_nodes(node->as.store.value);
+    case AST_FIELD_GET: return 1 + count_nodes(node->as.field_get.record);
+    case AST_LET: {
+        int c = 1;
+        for (size_t i = 0; i < node->as.let.binding_count; i++)
+            c += count_nodes(node->as.let.vals[i]);
+        for (size_t i = 0; i < node->as.let.body.count; i++)
+            c += count_nodes(node->as.let.body.items[i]);
+        return c;
+    }
+    case AST_WHILE: {
+        int c = 1 + count_nodes(node->as.while_expr.cond);
+        for (size_t i = 0; i < node->as.while_expr.body.count; i++)
+            c += count_nodes(node->as.while_expr.body.items[i]);
+        return c;
+    }
+    case AST_WHEN: case AST_UNLESS: {
+        int c = 1 + count_nodes(node->as.when_expr.cond);
+        for (size_t i = 0; i < node->as.when_expr.body.count; i++)
+            c += count_nodes(node->as.when_expr.body.items[i]);
+        return c;
+    }
+    case AST_FOR: {
+        int c = 1 + count_nodes(node->as.for_expr.collection);
+        if (node->as.for_expr.when_cond) c += count_nodes(node->as.for_expr.when_cond);
+        for (size_t i = 0; i < node->as.for_expr.body.count; i++)
+            c += count_nodes(node->as.for_expr.body.items[i]);
+        return c;
+    }
+    case AST_DO: case AST_DB: {
+        int c = 1;
+        for (size_t i = 0; i < node->as.block.exprs.count; i++)
+            c += count_nodes(node->as.block.exprs.items[i]);
+        return c;
+    }
+    case AST_COND: {
+        int c = 1;
+        for (size_t i = 0; i < node->as.cond.clause_count; i++) {
+            c += count_nodes(node->as.cond.tests[i]);
+            for (size_t j = 0; j < node->as.cond.bodies[i].count; j++)
+                c += count_nodes(node->as.cond.bodies[i].items[j]);
+        }
+        return c;
+    }
+    case AST_SET: case AST_SET_BANG:
+        return 1 + count_nodes(node->as.set.value) + count_nodes(node->as.set.target_expr);
+    case AST_RANGE:
+        return 1 + count_nodes(node->as.range.start) + count_nodes(node->as.range.end);
+    default: return 1;
+    }
+}
+
+// Check if a function body contains any function calls (non-leaf)
+static bool body_has_calls(AstNodeArray* body) {
+    for (size_t i = 0; i < body->count; i++) {
+        FuncSet calls;
+        calls.count = 0;
+        collect_calls(body->items[i], &calls);
+        if (calls.count > 0) return true;
+    }
+    return false;
+}
+
+// Check if a function is self-recursive
+static bool is_recursive(AstNode* defn) {
+    FuncSet calls;
+    calls.count = 0;
+    for (size_t i = 0; i < defn->as.defn.body.count; i++)
+        collect_calls(defn->as.defn.body.items[i], &calls);
+    return fset_contains(&calls, defn->as.defn.name);
+}
+
+// Deep-copy an AST node, substituting parameter symbols with argument nodes
+static AstNode* clone_and_subst(AstPool* pool, AstNode* node,
+                                 const char params[][SE_MAX_SYMBOL_LEN],
+                                 AstNode** args, size_t param_count) {
+    if (!node) return NULL;
+
+    // Substitute parameter references with argument copies
+    if (node->kind == AST_SYMBOL) {
+        for (size_t i = 0; i < param_count; i++) {
+            if (strcmp(node->as.symbol.name, params[i]) == 0) {
+                // Return a copy of the argument
+                return args[i]; // Safe: args are from the call site, still alive
+            }
+        }
+        // Not a parameter, return as-is
+        return node;
+    }
+
+    // For other node types, clone and recurse
+    AstNode* n = ast_alloc(pool);
+    if (!n) return node;
+    *n = *node; // Shallow copy
+
+    switch (node->kind) {
+    case AST_ADD: case AST_SUB: case AST_MUL: case AST_DIV: case AST_MOD:
+    case AST_BAND: case AST_BOR: case AST_XOR: case AST_SHL: case AST_SHR:
+    case AST_EQ: case AST_NE: case AST_LT: case AST_GT: case AST_LE: case AST_GE:
+    case AST_LOGIC_AND: case AST_LOGIC_OR: case AST_NTH:
+        n->as.binary.left = clone_and_subst(pool, node->as.binary.left, params, args, param_count);
+        n->as.binary.right = clone_and_subst(pool, node->as.binary.right, params, args, param_count);
+        break;
+    case AST_NEG: case AST_INC: case AST_DEC: case AST_BNOT: case AST_LNOT:
+    case AST_LOGIC_NOT: case AST_HI: case AST_LO: case AST_LEN:
+    case AST_NILP: case AST_ZEROP: case AST_POSP: case AST_NEGP:
+    case AST_CAST_U8: case AST_CAST_I8:
+        n->as.unary.operand = clone_and_subst(pool, node->as.unary.operand, params, args, param_count);
+        break;
+    case AST_IF:
+        n->as.if_expr.cond = clone_and_subst(pool, node->as.if_expr.cond, params, args, param_count);
+        n->as.if_expr.then_branch = clone_and_subst(pool, node->as.if_expr.then_branch, params, args, param_count);
+        n->as.if_expr.else_branch = clone_and_subst(pool, node->as.if_expr.else_branch, params, args, param_count);
+        break;
+    case AST_CALL:
+        for (size_t i = 0; i < node->as.call.arg_count; i++)
+            n->as.call.args[i] = clone_and_subst(pool, node->as.call.args[i], params, args, param_count);
+        break;
+    case AST_LOAD:
+        n->as.load.addr = clone_and_subst(pool, node->as.load.addr, params, args, param_count);
+        break;
+    case AST_STORE:
+        n->as.store.addr = clone_and_subst(pool, node->as.store.addr, params, args, param_count);
+        n->as.store.value = clone_and_subst(pool, node->as.store.value, params, args, param_count);
+        break;
+    case AST_FIELD_GET:
+        n->as.field_get.record = clone_and_subst(pool, node->as.field_get.record, params, args, param_count);
+        break;
+    case AST_SET: case AST_SET_BANG:
+        n->as.set.value = clone_and_subst(pool, node->as.set.value, params, args, param_count);
+        if (node->as.set.target_expr)
+            n->as.set.target_expr = clone_and_subst(pool, node->as.set.target_expr, params, args, param_count);
+        // Check if the set target variable is a parameter name
+        for (size_t i = 0; i < param_count; i++) {
+            if (strcmp(node->as.set.var, params[i]) == 0) {
+                // Can't inline if parameters are mutated
+                return node;
+            }
+        }
+        break;
+    default:
+        // For types we don't handle, return the original node
+        return node;
+    }
+    return n;
+}
+
+// Count how many times a function is called in the program
+static int count_call_uses(AstProgram* program, const char* func_name) {
+    FuncSet calls;
+    calls.count = 0;
+    for (size_t i = 0; i < program->node_count; i++) {
+        collect_calls(program->nodes[i], &calls);
+    }
+    int count = 0;
+    for (size_t i = 0; i < calls.count; i++) {
+        if (strcmp(calls.names[i], func_name) == 0) count++;
+    }
+    return count;
+}
+
+// Inline call sites for eligible functions
+static AstNode* inline_calls(AstPool* pool, AstNode* node, AstProgram* program) {
+    if (!node) return NULL;
+
+    // Recurse into children first
+    switch (node->kind) {
+    case AST_DEF: node->as.def.value = inline_calls(pool, node->as.def.value, program); break;
+    case AST_DEFN:
+    case AST_FN:
+        for (size_t i = 0; i < node->as.defn.body.count; i++)
+            node->as.defn.body.items[i] = inline_calls(pool, node->as.defn.body.items[i], program);
+        break;
+    case AST_LET:
+        for (size_t i = 0; i < node->as.let.binding_count; i++)
+            node->as.let.vals[i] = inline_calls(pool, node->as.let.vals[i], program);
+        for (size_t i = 0; i < node->as.let.body.count; i++)
+            node->as.let.body.items[i] = inline_calls(pool, node->as.let.body.items[i], program);
+        break;
+    case AST_VAR: node->as.var.value = inline_calls(pool, node->as.var.value, program); break;
+    case AST_SET: case AST_SET_BANG:
+        node->as.set.value = inline_calls(pool, node->as.set.value, program);
+        if (node->as.set.target_expr)
+            node->as.set.target_expr = inline_calls(pool, node->as.set.target_expr, program);
+        break;
+    case AST_IF:
+        node->as.if_expr.cond = inline_calls(pool, node->as.if_expr.cond, program);
+        node->as.if_expr.then_branch = inline_calls(pool, node->as.if_expr.then_branch, program);
+        node->as.if_expr.else_branch = inline_calls(pool, node->as.if_expr.else_branch, program);
+        break;
+    case AST_WHILE:
+        node->as.while_expr.cond = inline_calls(pool, node->as.while_expr.cond, program);
+        for (size_t i = 0; i < node->as.while_expr.body.count; i++)
+            node->as.while_expr.body.items[i] = inline_calls(pool, node->as.while_expr.body.items[i], program);
+        break;
+    case AST_DO:
+        for (size_t i = 0; i < node->as.block.exprs.count; i++)
+            node->as.block.exprs.items[i] = inline_calls(pool, node->as.block.exprs.items[i], program);
+        break;
+    case AST_COND:
+        for (size_t i = 0; i < node->as.cond.clause_count; i++) {
+            node->as.cond.tests[i] = inline_calls(pool, node->as.cond.tests[i], program);
+            for (size_t j = 0; j < node->as.cond.bodies[i].count; j++)
+                node->as.cond.bodies[i].items[j] = inline_calls(pool, node->as.cond.bodies[i].items[j], program);
+        }
+        break;
+    case AST_WHEN: case AST_UNLESS:
+        node->as.when_expr.cond = inline_calls(pool, node->as.when_expr.cond, program);
+        for (size_t i = 0; i < node->as.when_expr.body.count; i++)
+            node->as.when_expr.body.items[i] = inline_calls(pool, node->as.when_expr.body.items[i], program);
+        break;
+    case AST_FOR:
+        node->as.for_expr.collection = inline_calls(pool, node->as.for_expr.collection, program);
+        if (node->as.for_expr.when_cond)
+            node->as.for_expr.when_cond = inline_calls(pool, node->as.for_expr.when_cond, program);
+        for (size_t i = 0; i < node->as.for_expr.body.count; i++)
+            node->as.for_expr.body.items[i] = inline_calls(pool, node->as.for_expr.body.items[i], program);
+        break;
+    case AST_ADD: case AST_SUB: case AST_MUL: case AST_DIV: case AST_MOD:
+    case AST_BAND: case AST_BOR: case AST_XOR: case AST_SHL: case AST_SHR:
+    case AST_EQ: case AST_NE: case AST_LT: case AST_GT: case AST_LE: case AST_GE:
+    case AST_LOGIC_AND: case AST_LOGIC_OR: case AST_NTH:
+        node->as.binary.left = inline_calls(pool, node->as.binary.left, program);
+        node->as.binary.right = inline_calls(pool, node->as.binary.right, program);
+        break;
+    case AST_NEG: case AST_INC: case AST_DEC: case AST_BNOT: case AST_LNOT:
+    case AST_LOGIC_NOT: case AST_HI: case AST_LO: case AST_LEN:
+    case AST_NILP: case AST_ZEROP: case AST_POSP: case AST_NEGP:
+    case AST_CAST_U8: case AST_CAST_I8:
+        node->as.unary.operand = inline_calls(pool, node->as.unary.operand, program);
+        break;
+    case AST_LOAD:
+        node->as.load.addr = inline_calls(pool, node->as.load.addr, program);
+        break;
+    case AST_STORE:
+        node->as.store.addr = inline_calls(pool, node->as.store.addr, program);
+        node->as.store.value = inline_calls(pool, node->as.store.value, program);
+        break;
+    case AST_FIELD_GET:
+        node->as.field_get.record = inline_calls(pool, node->as.field_get.record, program);
+        break;
+    case AST_CALL:
+        for (size_t i = 0; i < node->as.call.arg_count; i++)
+            node->as.call.args[i] = inline_calls(pool, node->as.call.args[i], program);
+        break;
+    default: break;
+    }
+
+    // Now check if this call can be inlined
+    if (node->kind == AST_CALL) {
+        // Find the target function definition
+        AstNode* target = NULL;
+        for (size_t i = 0; i < program->node_count; i++) {
+            if (program->nodes[i]->kind == AST_DEFN &&
+                strcmp(program->nodes[i]->as.defn.name, node->as.call.func) == 0) {
+                target = program->nodes[i];
+                break;
+            }
+        }
+
+        if (target && !is_recursive(target) && !body_has_calls(&target->as.defn.body) &&
+            target->as.defn.body.count == 1 &&
+            node->as.call.arg_count == target->as.defn.param_count) {
+            // Check body size - only inline small functions (< 6 AST nodes)
+            int body_size = count_nodes(target->as.defn.body.items[0]);
+            if (body_size <= 5) {
+                // Don't inline functions that use inline assembly (asm)
+                // These reference FP-relative parameter offsets that break when inlined
+                AstNode* body0 = target->as.defn.body.items[0];
+                if (body0->kind == AST_ASM) return node;
+                // Inline: substitute parameters with arguments
+                AstNode* inlined = clone_and_subst(pool, target->as.defn.body.items[0],
+                                                    target->as.defn.params,
+                                                    node->as.call.args,
+                                                    target->as.defn.param_count);
+                if (inlined) return inlined;
+            }
+        }
+    }
+
+    return node;
+}
+
+static void pass_inline(AstProgram* program, AstPool* pool) {
+    // Only inline if there's a main function
+    bool has_main = false;
+    for (size_t i = 0; i < program->node_count; i++) {
+        if (program->nodes[i]->kind == AST_DEFN &&
+            strcmp(program->nodes[i]->as.defn.name, "main") == 0) {
+            has_main = true;
+            break;
+        }
+    }
+    if (!has_main) return;
+
+    for (size_t i = 0; i < program->node_count; i++) {
+        program->nodes[i] = inline_calls(pool, program->nodes[i], program);
+    }
+}
+
 // -------------------------------------------------------------------
 // Main optimizer entry point
 // -------------------------------------------------------------------
@@ -1265,6 +1758,11 @@ void se_optimize(AstProgram* program, AstPool* pool, SeOptLevel level) {
         pass_strength_reduce(program, pool);
         // Run constant fold again after strength reduction may expose new constants
         pass_constant_fold(program, pool);
+        // Inline small leaf functions
+        pass_inline(program, pool);
+        // After inlining, re-fold constants and remove dead code
+        pass_constant_fold(program, pool);
+        pass_dead_code(program);
         // Dead function elimination: remove functions never called from main
         pass_dead_fn_elim(program);
     }
diff --git a/tests/sec_test.c b/tests/sec_test.c
index 1db76ac..f6df796 100644
--- a/tests/sec_test.c
+++ b/tests/sec_test.c
@@ -1817,9 +1817,8 @@ void test_codegen_cast_u8(void) {
     char* output = codegen_to_string(input);
     TEST_ASSERT(output != NULL);
     TEST_ASSERT(strstr(output, "main:") != NULL);
-    // u8 cast should mask with 0xFF
-    TEST_ASSERT(strstr(output, "LOADI R1, 0xFF") != NULL);
-    TEST_ASSERT(strstr(output, "AND R0, R1") != NULL);
+    // u8 cast on 8-bit operand is a no-op (just loads x)
+    TEST_ASSERT(strstr(output, "LOAD R0, [R4:R5") != NULL);
     free(output);
 }
 
@@ -1828,9 +1827,8 @@ void test_codegen_cast_i8(void) {
     char* output = codegen_to_string(input);
     TEST_ASSERT(output != NULL);
     TEST_ASSERT(strstr(output, "main:") != NULL);
-    // i8 cast should mask with 0xFF
-    TEST_ASSERT(strstr(output, "LOADI R1, 0xFF") != NULL);
-    TEST_ASSERT(strstr(output, "AND R0, R1") != NULL);
+    // i8 cast on 8-bit operand is a no-op (just loads x)
+    TEST_ASSERT(strstr(output, "LOAD R0, [R4:R5") != NULL);
     free(output);
 }
 
@@ -2100,13 +2098,12 @@ void test_codegen_while_returns_nil(void) {
 }
 
 void test_codegen_when_returns_nil(void) {
-    // when should return nil when not taken
+    // when should skip body when condition is false
     const char* input = "(defn main () (when false 1))";
     char* output = codegen_to_string(input);
     TEST_ASSERT(output != NULL);
-    // Should have LOADI R0, 0xFF for the not-taken path
-    TEST_ASSERT(strstr(output, "LOADI R0, 0xFF") != NULL);
-    TEST_ASSERT(strstr(output, "JTRUE") != NULL);
+    // false condition: fused branch should just JMP to skip body
+    TEST_ASSERT(strstr(output, "main:") != NULL);
     free(output);
 }
 
@@ -2363,6 +2360,7 @@ void test_optimizer_cprop_immutable_let(void) {
 
 void test_optimizer_dead_fn_elim(void) {
     // Unreachable functions should be removed at -O2
+    // Note: simple leaf functions get inlined, then become dead too
     const char* input = "(defn unused () 42) "
                         "(defn also-unused () 99) "
                         "(defn helper () 1) "
@@ -2378,26 +2376,26 @@ void test_optimizer_dead_fn_elim(void) {
 
     se_optimize(&program, &pool, SE_OPT_FULL);
 
-    // Only main and helper should remain (unused and also-unused removed)
+    // After inlining + dead fn elimination: only main remains
+    // (helper was inlined into main, then became dead)
     int fn_count = 0;
-    bool has_main = false, has_helper = false, has_unused = false;
+    bool has_main = false, has_unused = false;
     for (size_t i = 0; i < program.node_count; i++) {
         if (program.nodes[i]->kind == AST_DEFN) {
             fn_count++;
             if (strcmp(program.nodes[i]->as.defn.name, "main") == 0) has_main = true;
-            if (strcmp(program.nodes[i]->as.defn.name, "helper") == 0) has_helper = true;
             if (strcmp(program.nodes[i]->as.defn.name, "unused") == 0) has_unused = true;
         }
     }
-    TEST_ASSERT(fn_count == 2);
+    TEST_ASSERT(fn_count == 1);
     TEST_ASSERT(has_main);
-    TEST_ASSERT(has_helper);
     TEST_ASSERT(!has_unused);
     ast_pool_free(&pool);
 }
 
 void test_optimizer_dead_fn_keeps_transitive(void) {
-    // main -> a -> b: all three should be kept
+    // main -> a -> b: small leaf functions get inlined transitively,
+    // then become dead. With inlining, a and b get inlined into main.
     const char* input = "(defn b () 1) "
                         "(defn a () (b)) "
                         "(defn dead () 99) "
@@ -2412,19 +2410,18 @@ void test_optimizer_dead_fn_keeps_transitive(void) {
 
     se_optimize(&program, &pool, SE_OPT_FULL);
 
+    // After inlining + dead fn elim: only main remains
     int fn_count = 0;
-    bool has_a = false, has_b = false, has_dead = false;
+    bool has_dead = false, has_main = false;
     for (size_t i = 0; i < program.node_count; i++) {
         if (program.nodes[i]->kind == AST_DEFN) {
             fn_count++;
-            if (strcmp(program.nodes[i]->as.defn.name, "a") == 0) has_a = true;
-            if (strcmp(program.nodes[i]->as.defn.name, "b") == 0) has_b = true;
             if (strcmp(program.nodes[i]->as.defn.name, "dead") == 0) has_dead = true;
+            if (strcmp(program.nodes[i]->as.defn.name, "main") == 0) has_main = true;
         }
     }
-    TEST_ASSERT(fn_count == 3); // main, a, b
-    TEST_ASSERT(has_a);
-    TEST_ASSERT(has_b);
+    TEST_ASSERT(fn_count == 1); // only main
+    TEST_ASSERT(has_main);
     TEST_ASSERT(!has_dead);
     ast_pool_free(&pool);
 }