Barmaja-PyArduino 2.0.0__py3-none-any.whl

Barmaja_PyArduino/backend/uno_cpp.py

@@ -0,0 +1,1680 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, fields, is_dataclass
+from typing import Any
+
+from ..errors import InternalCompilerError
+from ..flow import StorageClass
+from ..ir import (
+    IRAugStore, IRBinary, IRBinaryOp, IRBool, IRBoolOp, IRBreak, IRCall, IRCallKind,
+    IRCompareChain, IRCompareOp, IRConditional, IRConstant, IRContinue, IREffect,
+    IRExpr, IRExprStmt, IRFixedListLoop, IRFormatString, IRFormattedValue, IRFunction,
+    IRIf, IRIndex, IRIndexStore, IRListLiteral, IRLoad, IRLoopControlTarget, IRModule,
+    IRPrint, IRRangeLoop, IRReturn, IRStmt, IRStore, IRSymbolRef,
+    IRTempRef, IRUnary, IRUnaryOp, IRWhile, validate_ir,
+)
+from ..source import SourceSpan
+from ..symbols import SymbolKind
+from ..target import TargetDiagnostic, TargetPlan
+from ..typesys import TypeKind
+
+
+@dataclass(frozen=True)
+class SourceMapEntry:
+    cpp_line: int
+    source_name: str
+    span: SourceSpan
+
+
+@dataclass(frozen=True)
+class GeneratedSketch:
+    cpp: str
+    source_map: tuple[SourceMapEntry, ...]
+    dependency_ids: tuple[str, ...]
+    resolved_serial_baud: int | None
+    diagnostics: tuple[TargetDiagnostic, ...]
+
+
+@dataclass(frozen=True)
+class _OutputPart:
+    literal: str | None = None
+    expression: str | None = None
+    type_kind: TypeKind | None = None
+    precision: int | None = None
+
+
+# _bj_numeric_fail() halts the Uno.  Its loop MUST contain a side effect and stay out of
+# line: with the pinned avr-gcc 7.3.0 + -Os -flto, an empty `for (;;) {}` let GCC's
+# control-dependent DCE delete the non-failing path after an inlined check (WA-26).
+_NUMERIC_HELPER_BLOB ='static void __attribute__((noinline, noreturn)) _bj_numeric_fail() {\n    for (;;) { __asm__ __volatile__(""); }\n}\nstatic int32_t _bj_list_index(int32_t index, int32_t length) {\n    if (index < 0 || index >= length) _bj_numeric_fail();\n    return index;\n}\nstatic int32_t _bj_i32_add(int32_t a, int32_t b) {\n    int64_t r = (int64_t)a + (int64_t)b;\n    if (r < (-2147483647LL - 1LL) || r > 2147483647LL) _bj_numeric_fail();\n    return (int32_t)r;\n}\nstatic int32_t _bj_i32_sub(int32_t a, int32_t b) {\n    int64_t r = (int64_t)a - (int64_t)b;\n    if (r < (-2147483647LL - 1LL) || r > 2147483647LL) _bj_numeric_fail();\n    return (int32_t)r;\n}\nstatic int32_t _bj_i32_mul(int32_t a, int32_t b) {\n    int64_t r = (int64_t)a * (int64_t)b;\n    if (r < (-2147483647LL - 1LL) || r > 2147483647LL) _bj_numeric_fail();\n    return (int32_t)r;\n}\nstatic int32_t _bj_i32_neg(int32_t value) {\n    if (value == (-2147483647L - 1L)) _bj_numeric_fail();\n    return -value;\n}\nstatic float _bj_true_div_f32(float a, float b) {\n    if (b == 0.0f) _bj_numeric_fail();\n    return a / b;\n}\nstatic int32_t _bj_mod_i32(int32_t a, int32_t b) {\n    if (b == 0) _bj_numeric_fail();\n    if (a == (-2147483647L - 1L) && b == -1) return 0;\n    int32_t r = a % b;\n    if (r != 0 && ((r < 0) != (b < 0))) r += b;\n    return r;\n}\nstatic float _bj_mod_f32(float a, float b) {\n    if (isnan(a) || isnan(b) || isinf(a) || isinf(b) || b == 0.0f) _bj_numeric_fail();\n    float r = fmodf(a, b);\n    if (r != 0.0f && ((r < 0.0f) != (b < 0.0f))) r += b;\n    if (r == 0.0f) r = copysignf(0.0f, b);\n    return r;\n}\nstatic int32_t _bj_digital_pin(int32_t pin) {\n    if (pin < 0 || pin > 19) _bj_numeric_fail();\n    return pin;\n}\nstatic int32_t _bj_pwm_pin(int32_t pin) {\n    if (!(pin == 3 || pin == 5 || pin == 6 || pin == 9 || pin == 10 || pin == 11)) _bj_numeric_fail();\n    return pin;\n}\nstatic int32_t _bj_analog_pin(int32_t pin) {\n    if (!((pin >= 0 && pin <= 5) || (pin >= 14 && pin <= 19))) _bj_numeric_fail();\n    return pin;\n}\nstatic int32_t _bj_servo_angle(int32_t value) {\n    if (value < 0 || value > 180) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_servo_pulse(int32_t value) {\n    if (value < 0 || value > 3000) _bj_numeric_fail();\n    return value;\n}\nstatic void _bj_servo_attach_bounds(int32_t min_us, int32_t max_us) {\n    int64_t dmin = 544LL - (int64_t)min_us; if (dmin < 0) dmin = -dmin;\n    int64_t dmax = 2400LL - (int64_t)max_us; if (dmax < 0) dmax = -dmax;\n    if (min_us <= 0 || min_us >= max_us || dmin / 4LL >= 128LL || dmax / 4LL >= 128LL) _bj_numeric_fail();\n}\nstatic int32_t _bj_pwm_value(int32_t value) {\n    if (value < 0 || value > 255) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_byte_value(int32_t value) {\n    if (value < 0 || value > 255) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_digital_level(int32_t value) {\n    if (value < 0 || value > 1) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_pin_mode(int32_t value) {\n    if (!(value == 0 || value == 1 || value == 2)) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_i2c_address(int32_t value) {\n    if (value < 0 || value > 127) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_arduino_format(int32_t value) {\n    if (value < 0 || value > 255) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_wire_count(int32_t value) {\n    if (value < 0 || value > 255) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_nonnegative_int(int32_t value) {\n    if (value < 0) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_lcd_dimension(int32_t value) {\n    if (value < 1 || value > 255) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_lcd_charsize(int32_t value) {\n    if (!(value == 0 || value == 4)) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_lcd_cursor_column(int32_t value) {\n    if (value < 0 || value > 255) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_lcd_cursor_row(int32_t value) {\n    if (value < 0 || value > 3) _bj_numeric_fail();\n    return value;\n}\nstatic int32_t _bj_positive_int(int32_t value) {\n    if (value <= 0) _bj_numeric_fail();\n    return value;\n}\nstatic uint32_t _bj_time_threshold(int32_t value) {\n    if (value < 0) _bj_numeric_fail();\n    return (uint32_t)value;\n}\nstatic int32_t _bj_float_to_i32(float value) {\n    if (isnan(value) || isinf(value) || value < -2147483648.0f || value >= 2147483648.0f) _bj_numeric_fail();\n    return (int32_t)value;\n}\nstatic float _bj_round_even_f32(float value) {\n    float base = floorf(value);\n    float frac = value - base;\n    if (frac > 0.5f) return base + 1.0f;\n    if (frac < 0.5f) return base;\n    return (fmodf(fabsf(base), 2.0f) == 0.0f) ? base : (base + 1.0f);\n}\nstatic int32_t _bj_round_i32(float value) {\n    if (isnan(value) || isinf(value) || value < -2147483648.0f || value >= 2147483648.0f) _bj_numeric_fail();\n    float rounded = _bj_round_even_f32(value);\n    if (rounded < -2147483648.0f || rounded >= 2147483648.0f) _bj_numeric_fail();\n    return (int32_t)rounded;\n}\nstatic __attribute__((noinline)) uint64_t _bj_round_ratio_even_u64(uint64_t num, uint64_t den) {\n    uint64_t q = num / den;\n    uint64_t r = num % den;\n    uint64_t twice = r * 2ULL;\n    if (twice > den || (twice == den && (q & 1ULL))) ++q;\n    return q;\n}\nstatic __attribute__((noinline)) uint64_t _bj_round_pow2_even_u64(uint64_t num, uint8_t shift) {\n    if (shift == 0) return num;\n    if (shift >= 64) return 0;\n    uint64_t q = num >> shift;\n    uint64_t mask = (1ULL << shift) - 1ULL;\n    uint64_t r = num & mask;\n    uint64_t half = 1ULL << (shift - 1);\n    if (r > half || (r == half && (q & 1ULL))) ++q;\n    return q;\n}\nstatic __attribute__((noinline)) float _bj_ratio_to_f32(bool negative, uint64_t num, uint64_t den) {\n    union { uint32_t u; float f; } out;\n    if (num == 0) { out.u = negative ? 0x80000000UL : 0UL; return out.f; }\n    int16_t exponent = 0;\n    if (num >= den) {\n        uint64_t scaled_den = den;\n        while (num >= (scaled_den << 1)) { scaled_den <<= 1; ++exponent; }\n    } else {\n        uint64_t scaled_num = num;\n        while (scaled_num < den) { scaled_num <<= 1; --exponent; }\n    }\n    int16_t shift = 23 - exponent;\n    uint64_t scaled_num = num;\n    uint64_t scaled_den = den;\n    if (shift >= 0) scaled_num <<= shift; else scaled_den <<= -shift;\n    uint64_t significand = _bj_round_ratio_even_u64(scaled_num, scaled_den);\n    if (significand == (1ULL << 24)) { significand >>= 1; ++exponent; }\n    uint32_t exponent_bits = (uint32_t)(exponent + 127);\n    if (exponent_bits == 0 || exponent_bits >= 255) _bj_numeric_fail();\n    out.u = (negative ? 0x80000000UL : 0UL) | (exponent_bits << 23) | ((uint32_t)significand & 0x7FFFFFUL);\n    return out.f;\n}\nstatic float _bj_round_f32_digits(float value, int8_t ndigits) {\n    if (isnan(value) || isinf(value) || value == 0.0f) return value;\n    union { float f; uint32_t u; } bits; bits.f = value;\n    bool negative = (bits.u & 0x80000000UL) != 0;\n    uint32_t exp_bits = (bits.u >> 23) & 0xFFUL;\n    uint32_t fraction = bits.u & 0x7FFFFFUL;\n    uint64_t mantissa; int16_t exponent2; int16_t unbiased;\n    if (exp_bits == 0) { mantissa = fraction; exponent2 = -149; unbiased = -126; }\n    else { mantissa = (1UL << 23) | fraction; unbiased = (int16_t)exp_bits - 127; exponent2 = unbiased - 23; }\n    static const uint32_t p5[7] = {1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL};\n    static const uint32_t p10[7] = {1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL, 1000000UL};\n    if (ndigits >= 0) {\n        if (unbiased >= 23) return value;\n        uint8_t n = (uint8_t)ndigits;\n        uint64_t mag = mantissa * (uint64_t)p5[n];\n        int16_t shift2 = exponent2 + n;\n        uint64_t rounded;\n        if (shift2 >= 0) rounded = mag << shift2;\n        else rounded = _bj_round_pow2_even_u64(mag, (uint8_t)(-shift2));\n        return _bj_ratio_to_f32(negative, rounded, p10[n]);\n    }\n    uint8_t n = (uint8_t)(-ndigits);\n    if (unbiased >= 43) return value;\n    int16_t shift2 = exponent2 - n;\n    uint64_t rounded;\n    if (shift2 >= 0) {\n        uint64_t numerator = mantissa << shift2;\n        rounded = _bj_round_ratio_even_u64(numerator, p5[n]);\n    } else {\n        uint8_t down = (uint8_t)(-shift2);\n        if (down >= 24) rounded = 0;\n        else rounded = _bj_round_ratio_even_u64(mantissa, ((uint64_t)p5[n]) << down);\n    }\n    return _bj_ratio_to_f32(negative, rounded * (uint64_t)p10[n], 1UL);\n}\nstatic int32_t _bj_round_i32_digits(int32_t value, int8_t ndigits) {\n    if (ndigits >= 0) return value;\n    static const int32_t p10[7] = {1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L};\n    int64_t scale = p10[-ndigits];\n    int64_t q = ((int64_t)value) / scale;\n    int64_t r = ((int64_t)value) % scale;\n    int64_t ar = r < 0 ? -r : r;\n    int64_t twice = ar * 2LL;\n    if (twice > scale || (twice == scale && (q % 2LL) != 0LL)) q += value < 0 ? -1LL : 1LL;\n    int64_t result = q * scale;\n    if (result < (-2147483647LL - 1LL) || result > 2147483647LL) _bj_numeric_fail();\n    return (int32_t)result;\n}\nstatic int32_t _bj_i32_abs(int32_t value) {\n    if (value == (-2147483647L - 1L)) _bj_numeric_fail();\n    return value < 0 ? -value : value;\n}\nstatic bool _bj_str_eq(const char* a, const char* b) {\n    while (*a && *b && *a == *b) { ++a; ++b; }\n    return *a == *b;\n}\n'
+_OUTPUT_HELPER_PREAMBLE = 'typedef struct { uint16_t limb[12]; } _bj_big192;'
+_OUTPUT_HELPER_BLOB = r'''static __attribute__((noinline)) uint64_t _bj_pow5_u64(uint8_t n) {
+    uint64_t r = 1ULL;
+    while (n--) r *= 5ULL;
+    return r;
+}
+static __attribute__((noinline)) float _bj_f32_scale2(float value, int16_t shift) {
+    // Exact multiplication by 2^shift for normal results (replaces ldexp).
+    union { float f; uint32_t u; } bits; bits.f = value;
+    int16_t e = (int16_t)((bits.u >> 23) & 0xFFUL) + shift;
+    if (e <= 0 || e >= 255) return value * 0.0f + (shift > 0 ? INFINITY : 0.0f);
+    bits.u = (bits.u & 0x807FFFFFUL) | ((uint32_t)e << 23);
+    return bits.f;
+}
+static __attribute__((noinline)) bool _bj_f32_ge_pow10(uint64_t mantissa, int16_t exponent2, int16_t k) {
+    // Exact test of mantissa * 2^exponent2 >= 10^k for -9 <= k <= 16.
+    if (k >= 0) {
+        if (k > 16) return false;
+        uint64_t p5 = _bj_pow5_u64((uint8_t)k);
+        int16_t t = exponent2 - k;  /* mantissa * 2^t >= 5^k */
+        if (t >= 0) return t >= 40 || (mantissa << t) >= p5;
+        if (-t > 25) return false;
+        return mantissa >= (p5 << (-t));
+    }
+    int16_t u = -k;
+    if (u > 16) return true;
+    uint64_t lhs = mantissa * _bj_pow5_u64((uint8_t)u);  /* mantissa * 5^u * 2^(exponent2+u) >= 1 */
+    int16_t t = exponent2 + u;
+    if (t >= 0) return true;
+    if (-t >= 63) return false;
+    return lhs >= (1ULL << (-t));
+}
+static bool __attribute__((noinline)) _bj_f32_shortest(float value, char* digits, uint8_t* count, int16_t* exp10) {
+    // Exact shortest round-trip decimal for float32 in 1e-7 <= |value| < 1e16.
+    union { float f; uint32_t u; } bits; bits.f = value;
+    bool negative = (bits.u & 0x80000000UL) != 0;
+    uint32_t exp_bits = (bits.u >> 23) & 0xFFUL;
+    if (exp_bits == 0 || exp_bits == 0xFFUL) return false;
+    float magnitude = fabsf(value);
+    if (!(magnitude >= 1e-7f && magnitude < 1e16f)) return false;
+    uint64_t mantissa = (1ULL << 23) | (bits.u & 0x7FFFFFUL);
+    int16_t exponent2 = (int16_t)exp_bits - 150;
+    // Exact decimal exponent: 10^k <= |value| < 10^(k+1); integer log10(2) estimate then correction.
+    int16_t k_estimate = (int16_t)(((int32_t)(exponent2 + 23) * 1233L) >> 12);
+    for (uint8_t fix = 0; fix < 6; ++fix) {
+        if (!_bj_f32_ge_pow10(mantissa, exponent2, k_estimate)) { --k_estimate; continue; }
+        if (_bj_f32_ge_pow10(mantissa, exponent2, (int16_t)(k_estimate + 1))) { ++k_estimate; continue; }
+        break;
+    }
+    uint32_t low = 1UL;  /* 10^(precision-1) */
+    for (uint8_t precision = 1; precision <= 9; ++precision, low *= 10UL) {
+        uint64_t high = (uint64_t)low * 10ULL;  /* 10^precision */
+        int16_t k = k_estimate;
+        uint64_t n = 0;
+        bool ok = false;
+        for (uint8_t attempt = 0; attempt < 4; ++attempt) {
+            int16_t s = (int16_t)precision - 1 - k;
+            if (s > 16 || s < -16) break;
+            if (s >= 0) {
+                uint64_t scaled = mantissa * _bj_pow5_u64((uint8_t)s);
+                int16_t t = exponent2 + s;
+                if (t >= 0) { if (t > 30) break; n = scaled << t; }
+                else n = _bj_round_pow2_even_u64(scaled, (uint8_t)((-t) > 64 ? 64 : (-t)));
+            } else {
+                uint8_t u = (uint8_t)(-s);
+                int16_t t = exponent2 - u;
+                if (t >= 0) { if (t > 30) break; n = _bj_round_ratio_even_u64(mantissa << t, _bj_pow5_u64(u)); }
+                else { int16_t shift = -t; if (shift > 25) break; n = _bj_round_ratio_even_u64(mantissa, _bj_pow5_u64(u) << shift); }
+            }
+            if (n >= high) { ++k; continue; }
+            if (n < low) { --k; continue; }
+            ok = true;
+            break;
+        }
+        if (!ok) continue;
+        int16_t s = (int16_t)precision - 1 - k;
+        float back = (s >= 0)
+            ? _bj_f32_scale2(_bj_ratio_to_f32(negative, n, _bj_pow5_u64((uint8_t)s)), (int16_t)(-s))
+            : _bj_f32_scale2(_bj_ratio_to_f32(negative, n * _bj_pow5_u64((uint8_t)(-s)), 1ULL), (int16_t)(-s));
+        if (back == value) {
+            uint32_t x = (uint32_t)n;
+            for (int8_t i = (int8_t)precision - 1; i >= 0; --i) { digits[i] = (char)('0' + (x % 10UL)); x /= 10UL; }
+            *count = precision;
+            *exp10 = k;
+            return true;
+        }
+    }
+    return false;
+}
+// Full-range exact fallback for float32.  The AVR libc decimal conversion
+// routines are not correctly-rounded enough for shortest-repr decisions at
+// the exponent extremes, so this path uses integer arithmetic and IEEE-754 interval
+// boundaries.  12 base-2^16 limbs (192 bits) are sufficient for every
+// binary32 value scaled by the powers of five needed for 1..9 decimal digits.
+static void _bj_big_zero(_bj_big192* a) {
+    for (uint8_t i = 0; i < 12; ++i) a->limb[i] = 0;
+}
+static void _bj_big_from_u32(_bj_big192* a, uint32_t value) {
+    _bj_big_zero(a);
+    a->limb[0] = (uint16_t)(value & 0xFFFFUL);
+    a->limb[1] = (uint16_t)(value >> 16);
+}
+static void _bj_big_copy(_bj_big192* dst, const _bj_big192* src) {
+    for (uint8_t i = 0; i < 12; ++i) dst->limb[i] = src->limb[i];
+}
+static void _bj_big_mul5(_bj_big192* a, uint8_t count) {
+    while (count--) {
+        uint32_t carry = 0;
+        for (uint8_t i = 0; i < 12; ++i) {
+            uint32_t v = (uint32_t)a->limb[i] * 5UL + carry;
+            a->limb[i] = (uint16_t)(v & 0xFFFFUL);
+            carry = v >> 16;
+        }
+    }
+}
+static void _bj_big_shl1(_bj_big192* a) {
+    uint16_t carry = 0;
+    for (uint8_t i = 0; i < 12; ++i) {
+        uint16_t next = (uint16_t)(a->limb[i] >> 15);
+        a->limb[i] = (uint16_t)((a->limb[i] << 1) | carry);
+        carry = next;
+    }
+}
+static void _bj_big_shr1(_bj_big192* a) {
+    uint16_t carry = 0;
+    for (int8_t i = 11; i >= 0; --i) {
+        uint16_t next = (uint16_t)(a->limb[i] & 1U);
+        a->limb[i] = (uint16_t)((a->limb[i] >> 1) | (uint16_t)(carry << 15));
+        carry = next;
+    }
+}
+static void _bj_big_shl(_bj_big192* a, uint16_t bits) {
+    while (bits--) _bj_big_shl1(a);
+}
+static void _bj_big_shr(_bj_big192* a, uint16_t bits) {
+    while (bits--) _bj_big_shr1(a);
+}
+static int8_t _bj_big_cmp(const _bj_big192* a, const _bj_big192* b) {
+    for (int8_t i = 11; i >= 0; --i) {
+        if (a->limb[i] < b->limb[i]) return -1;
+        if (a->limb[i] > b->limb[i]) return 1;
+    }
+    return 0;
+}
+static void _bj_big_sub(_bj_big192* a, const _bj_big192* b) {
+    uint32_t borrow = 0;
+    for (uint8_t i = 0; i < 12; ++i) {
+        uint32_t av = a->limb[i];
+        uint32_t bv = (uint32_t)b->limb[i] + borrow;
+        if (av >= bv) { a->limb[i] = (uint16_t)(av - bv); borrow = 0; }
+        else { a->limb[i] = (uint16_t)(0x10000UL + av - bv); borrow = 1; }
+    }
+}
+static uint16_t _bj_big_bitlen(const _bj_big192* a) {
+    for (int8_t i = 11; i >= 0; --i) {
+        uint16_t x = a->limb[i];
+        if (x) {
+            uint8_t n = 0;
+            while (x) { x >>= 1; ++n; }
+            return (uint16_t)((uint16_t)i * 16U + n);
+        }
+    }
+    return 0;
+}
+static bool _bj_big_to_u32(const _bj_big192* a, uint32_t* out) {
+    for (uint8_t i = 2; i < 12; ++i) if (a->limb[i]) return false;
+    *out = (uint32_t)a->limb[0] | ((uint32_t)a->limb[1] << 16);
+    return true;
+}
+static bool _bj_big_bit(const _bj_big192* a, uint16_t bit) {
+    if (bit >= 192) return false;
+    return ((a->limb[bit >> 4] >> (bit & 15)) & 1U) != 0;
+}
+static bool _bj_big_any_low_bits(const _bj_big192* a, uint16_t count) {
+    if (count > 192) count = 192;
+    for (uint16_t bit = 0; bit < count; ++bit) if (_bj_big_bit(a, bit)) return true;
+    return false;
+}
+static bool _bj_big_round_pow2_u32(const _bj_big192* input, uint16_t shift, uint32_t* out) {
+    if (shift >= 193) { *out = 0; return true; }
+    bool half = shift ? _bj_big_bit(input, (uint16_t)(shift - 1)) : false;
+    bool sticky = shift > 1 ? _bj_big_any_low_bits(input, (uint16_t)(shift - 1)) : false;
+    _bj_big192 q; _bj_big_copy(&q, input);
+    _bj_big_shr(&q, shift);
+    uint32_t value;
+    if (!_bj_big_to_u32(&q, &value)) return false;
+    if (half && (sticky || (value & 1UL))) ++value;
+    *out = value;
+    return true;
+}
+static bool _bj_big_div_round_u32(const _bj_big192* numerator, const _bj_big192* denominator, uint32_t* out) {
+    uint16_t den_bits = _bj_big_bitlen(denominator);
+    if (den_bits == 0) return false;
+    _bj_big192 rem; _bj_big_copy(&rem, numerator);
+    uint32_t q = 0;
+    uint16_t num_bits = _bj_big_bitlen(&rem);
+    if (num_bits >= den_bits) {
+        uint16_t shift = (uint16_t)(num_bits - den_bits);
+        _bj_big192 d; _bj_big_copy(&d, denominator); _bj_big_shl(&d, shift);
+        for (int16_t i = (int16_t)shift; i >= 0; --i) {
+            if (_bj_big_cmp(&rem, &d) >= 0) {
+                _bj_big_sub(&rem, &d);
+                if (i >= 32) return false;
+                q |= (1UL << i);
+            }
+            _bj_big_shr1(&d);
+        }
+    }
+    _bj_big192 twice; _bj_big_copy(&twice, &rem); _bj_big_shl1(&twice);
+    int8_t cmp = _bj_big_cmp(&twice, denominator);
+    if (cmp > 0 || (cmp == 0 && (q & 1UL))) ++q;
+    *out = q;
+    return true;
+}
+static int8_t _bj_dec_vs_binary(uint32_t n, int16_t scale10, uint32_t mantissa, int16_t exponent2) {
+    // Compare n * 10^(-scale10) with mantissa * 2^exponent2 exactly.
+    _bj_big192 a, b;
+    _bj_big_from_u32(&a, n);
+    _bj_big_from_u32(&b, mantissa);
+    if (scale10 >= 0) {
+        _bj_big_mul5(&b, (uint8_t)scale10);
+        int16_t q = (int16_t)(exponent2 + scale10);
+        if (q >= 0) _bj_big_shl(&b, (uint16_t)q);
+        else _bj_big_shl(&a, (uint16_t)(-q));
+    } else {
+        uint8_t t = (uint8_t)(-scale10);
+        _bj_big_mul5(&a, t);
+        int16_t q = (int16_t)(exponent2 - t);
+        if (q >= 0) _bj_big_shl(&b, (uint16_t)q);
+        else _bj_big_shl(&a, (uint16_t)(-q));
+    }
+    return _bj_big_cmp(&a, &b);
+}
+static bool _bj_scaled_decimal_round(uint32_t mantissa, int16_t exponent2, int16_t scale10, uint32_t* out) {
+    // Round mantissa * 2^exponent2 * 10^scale10 to the nearest integer, ties-to-even.
+    if (scale10 >= 0) {
+        _bj_big192 a; _bj_big_from_u32(&a, mantissa); _bj_big_mul5(&a, (uint8_t)scale10);
+        int16_t q = (int16_t)(exponent2 + scale10);
+        if (q >= 0) { _bj_big_shl(&a, (uint16_t)q); return _bj_big_to_u32(&a, out); }
+        return _bj_big_round_pow2_u32(&a, (uint16_t)(-q), out);
+    }
+    uint8_t t = (uint8_t)(-scale10);
+    _bj_big192 num, den;
+    _bj_big_from_u32(&num, mantissa);
+    _bj_big_from_u32(&den, 1UL); _bj_big_mul5(&den, t);
+    int16_t q = (int16_t)(exponent2 - t);
+    if (q >= 0) _bj_big_shl(&num, (uint16_t)q);
+    else _bj_big_shl(&den, (uint16_t)(-q));
+    return _bj_big_div_round_u32(&num, &den, out);
+}
+static void __attribute__((noinline)) _bj_f32_shortest_extreme(float value, char* digits, uint8_t* count, int16_t* exp10) {
+    union { float f; uint32_t u; } bits; bits.f = value;
+    uint32_t raw = bits.u & 0x7FFFFFFFUL;
+    uint32_t exp_bits = (raw >> 23) & 0xFFUL;
+    uint32_t fraction = raw & 0x7FFFFFUL;
+    uint32_t mantissa;
+    int16_t exponent2;
+    if (exp_bits == 0) { mantissa = fraction; exponent2 = -149; }
+    else { mantissa = (1UL << 23) | fraction; exponent2 = (int16_t)exp_bits - 150; }
+
+    // Exact lower/upper rounding boundaries, expressed as boundaryMantissa * 2^(exponent2-2).
+    // Powers of two have the closer lower neighbour; all other values use symmetric spacing.
+    uint32_t mm_shift = (fraction != 0 || exp_bits <= 1) ? 1UL : 0UL;
+    uint32_t lower_m = 4UL * mantissa - 1UL - mm_shift;
+    uint32_t upper_m = 4UL * mantissa + 2UL;
+    int16_t boundary_e2 = (int16_t)(exponent2 - 2);
+    bool accept_boundary = (mantissa & 1UL) == 0;  // IEEE ties-to-even.
+
+    uint8_t mbits = 0; for (uint32_t t = mantissa; t; t >>= 1) ++mbits;
+    int16_t floor_log2 = (int16_t)(exponent2 + (int16_t)mbits - 1);
+    int32_t prod = (int32_t)floor_log2 * 1233L;  // log10(2) approximation.
+    int16_t k = prod >= 0 ? (int16_t)(prod / 4096L)
+                           : (int16_t)(-(((-prod) + 4095L) / 4096L));
+    for (uint8_t fix = 0; fix < 6; ++fix) {
+        // Compare 10^k to the exact binary32 value.
+        if (_bj_dec_vs_binary(1UL, (int16_t)(-k), mantissa, exponent2) > 0) { --k; continue; }
+        if (_bj_dec_vs_binary(1UL, (int16_t)(-(k + 1)), mantissa, exponent2) <= 0) { ++k; continue; }
+        break;
+    }
+
+    uint32_t low = 1UL;
+    for (uint8_t precision = 1; precision <= 9; ++precision, low *= 10UL) {
+        uint32_t high = low * 10UL;
+        int16_t trial_k = k;
+        for (uint8_t adjust = 0; adjust < 4; ++adjust) {
+            int16_t scale10 = (int16_t)precision - 1 - trial_k;
+            uint32_t n = 0;
+            if (!_bj_scaled_decimal_round(mantissa, exponent2, scale10, &n)) break;
+            if (n >= high) { ++trial_k; continue; }
+            if (n < low) { --trial_k; continue; }
+            int8_t lo_cmp = _bj_dec_vs_binary(n, scale10, lower_m, boundary_e2);
+            int8_t hi_cmp = _bj_dec_vs_binary(n, scale10, upper_m, boundary_e2);
+            bool inside = accept_boundary ? (lo_cmp >= 0 && hi_cmp <= 0)
+                                          : (lo_cmp > 0 && hi_cmp < 0);
+            if (!inside) break;
+            uint32_t x = n;
+            for (int8_t i = (int8_t)precision - 1; i >= 0; --i) {
+                digits[i] = (char)('0' + (x % 10UL)); x /= 10UL;
+            }
+            *count = precision;
+            *exp10 = trial_k;
+            return;
+        }
+    }
+
+    // IEEE-754 binary32 always has a 9-significant-digit round-trip decimal.
+    // This defensive path remains non-halting even if a future compiler change
+    // violates an assumption in the shortest search.
+    int16_t scale10 = (int16_t)(8 - k);
+    uint32_t n = 0;
+    if (!_bj_scaled_decimal_round(mantissa, exponent2, scale10, &n)) n = mantissa;
+    if (n >= 1000000000UL) { n /= 10UL; ++k; }
+    while (n < 100000000UL) { n *= 10UL; --k; }
+    for (int8_t i = 8; i >= 0; --i) { digits[i] = (char)('0' + (n % 10UL)); n /= 10UL; }
+    *count = 9;
+    *exp10 = k;
+}
+static void __attribute__((noinline)) _bj_print_py_float(Print& out, float value) {
+    if (isnan(value)) { out.print(F("nan")); return; }
+    if (isinf(value)) { out.print(value < 0.0f ? F("-inf") : F("inf")); return; }
+    if (value == 0.0f) {
+        union { float f; uint32_t u; } bits; bits.f = value;
+        out.print((bits.u & 0x80000000UL) ? F("-0.0") : F("0.0"));
+        return;
+    }
+    char result[32]; char* w = result;
+    char digits[10]; uint8_t count = 0;
+    int16_t exponent = 0;
+    if (value < 0.0f) *w++ = '-';
+    if (!_bj_f32_shortest(value, digits, &count, &exponent)) {
+        _bj_f32_shortest_extreme(value, digits, &count, &exponent);
+    }
+    while (count > 1 && digits[count - 1] == '0') --count;
+    if (exponent >= -4 && exponent < 16) {
+        int16_t decimal_pos = exponent + 1;
+        if (decimal_pos <= 0) {
+            *w++ = '0'; *w++ = '.';
+            for (int16_t i = 0; i < -decimal_pos; ++i) *w++ = '0';
+            for (uint8_t i = 0; i < count; ++i) *w++ = digits[i];
+        } else {
+            for (int16_t i = 0; i < decimal_pos; ++i) *w++ = (i < count) ? digits[i] : '0';
+            *w++ = '.';
+            if (decimal_pos < count) {
+                for (uint8_t i = (uint8_t)decimal_pos; i < count; ++i) *w++ = digits[i];
+            } else {
+                *w++ = '0';
+            }
+        }
+    } else {
+        *w++ = digits[0];
+        if (count > 1) { *w++ = '.'; for (uint8_t i = 1; i < count; ++i) *w++ = digits[i]; }
+        *w++ = 'e';
+        int16_t e = exponent;
+        if (e < 0) { *w++ = '-'; e = -e; } else { *w++ = '+'; }
+        char expbuf[6]; uint8_t n = 0;
+        do { expbuf[n++] = (char)('0' + (e % 10)); e /= 10; } while (e && n < sizeof(expbuf));
+        if (n < 2) *w++ = '0';  // Python prints at least two exponent digits: 1e-05
+        while (n) *w++ = expbuf[--n];
+    }
+    *w = '\0';
+    out.print(result);
+}
+'''
+
+# Exact Python format(value, '.Nf') for float32 (N = 0..6). Arduino's
+# Print::print(float, N) rounds half-up in float arithmetic and prints 'ovf'
+# above 4294967040, which is not Python f-string behaviour.
+_FIXED_HELPER_BLOB = r'''static void __attribute__((noinline)) _bj_print_py_fixed(Print& out, float value, uint8_t digits) {
+    // Python format(value, '.Nf') for the exact float32 value: round-half-even of value*10^N.
+    if (isnan(value)) { out.print(F("nan")); return; }
+    if (isinf(value)) { out.print(value < 0.0f ? F("-inf") : F("inf")); return; }
+    union { float f; uint32_t u; } bits; bits.f = value;
+    if (bits.u & 0x80000000UL) out.print('-');
+    uint32_t exp_bits = (bits.u >> 23) & 0xFFUL;
+    uint32_t mant = bits.u & 0x7FFFFFUL;
+    int16_t e2 = -149;
+    if (exp_bits != 0) { mant |= 0x800000UL; e2 = (int16_t)exp_bits - 150; }
+    uint16_t limb[10];  // little-endian base-2^16; holds up to 2^160 > 2^128 * 10^6
+    for (uint8_t i = 0; i < 10; ++i) limb[i] = 0;
+    limb[0] = (uint16_t)(mant & 0xFFFFUL);
+    limb[1] = (uint16_t)(mant >> 16);
+    for (uint8_t d = 0; d < digits; ++d) {
+        uint32_t carry = 0;
+        for (uint8_t i = 0; i < 10; ++i) {
+            uint32_t t = (uint32_t)limb[i] * 10UL + carry;
+            limb[i] = (uint16_t)(t & 0xFFFFUL);
+            carry = t >> 16;
+        }
+    }
+    if (e2 > 0) {
+        uint8_t q = (uint8_t)(e2 >> 4), r = (uint8_t)(e2 & 15);
+        for (int8_t i = 9; i >= 0; --i) {
+            uint32_t hi = (i - (int8_t)q >= 0) ? (uint32_t)limb[i - q] : 0UL;
+            uint32_t lo = (i - (int8_t)q - 1 >= 0) ? (uint32_t)limb[i - q - 1] : 0UL;
+            limb[i] = (uint16_t)((((hi << 16) | lo) << r) >> 16);
+        }
+    } else if (e2 < 0) {
+        uint8_t k = (uint8_t)(-e2);
+        bool half = false, sticky = false;
+        if (k <= 160) {
+            uint8_t hb = (uint8_t)(k - 1);
+            half = ((uint32_t)limb[hb >> 4] >> (hb & 15)) & 1UL;
+            for (uint8_t b = 0; b < hb && !sticky; ++b) {
+                if (((uint32_t)limb[b >> 4] >> (b & 15)) & 1UL) sticky = true;
+            }
+        }
+        uint8_t q = (uint8_t)(k >> 4), r = (uint8_t)(k & 15);
+        for (uint8_t i = 0; i < 10; ++i) {
+            uint32_t lo = (i + q < 10) ? (uint32_t)limb[i + q] : 0UL;
+            uint32_t hi = (i + q + 1 < 10) ? (uint32_t)limb[i + q + 1] : 0UL;
+            limb[i] = (uint16_t)((((hi << 16) | lo) >> r) & 0xFFFFUL);
+        }
+        if (half && (sticky || (limb[0] & 1U))) {
+            for (uint8_t i = 0; i < 10; ++i) { if (++limb[i] != 0) break; }
+        }
+    }
+    char buf[50];
+    uint8_t n = 0;
+    for (;;) {
+        uint32_t rem = 0;
+        bool more = false;
+        for (int8_t i = 9; i >= 0; --i) {
+            uint32_t cur = (rem << 16) | (uint32_t)limb[i];
+            limb[i] = (uint16_t)(cur / 10UL);
+            rem = cur % 10UL;
+            if (limb[i]) more = true;
+        }
+        buf[n++] = (char)('0' + (char)rem);
+        if (!more) break;
+    }
+    while (n <= digits) buf[n++] = '0';
+    for (uint8_t i = n; i-- > digits;) out.print(buf[i]);
+    if (digits) {
+        out.print('.');
+        for (uint8_t i = digits; i-- > 0;) out.print(buf[i]);
+    }
+}
+'''
+
+_HELPER_DEPS: dict[str, tuple[str, ...]] = {
+    "_bj_list_index": ("_bj_numeric_fail",),
+    "_bj_i32_add": ("_bj_numeric_fail",),
+    "_bj_i32_sub": ("_bj_numeric_fail",),
+    "_bj_i32_mul": ("_bj_numeric_fail",),
+    "_bj_i32_neg": ("_bj_numeric_fail",),
+    "_bj_true_div_f32": ("_bj_numeric_fail",),
+    "_bj_mod_i32": ("_bj_numeric_fail",),
+    "_bj_mod_f32": ("_bj_numeric_fail",),
+    "_bj_pwm_value": ("_bj_numeric_fail",),
+    "_bj_byte_value": ("_bj_numeric_fail",),
+    "_bj_digital_level": ("_bj_numeric_fail",),
+    "_bj_pin_mode": ("_bj_numeric_fail",),
+    "_bj_i2c_address": ("_bj_numeric_fail",),
+    "_bj_arduino_format": ("_bj_numeric_fail",),
+    "_bj_wire_count": ("_bj_numeric_fail",),
+    "_bj_nonnegative_int": ("_bj_numeric_fail",),
+    "_bj_lcd_dimension": ("_bj_numeric_fail",),
+    "_bj_lcd_charsize": ("_bj_numeric_fail",),
+    "_bj_lcd_cursor_column": ("_bj_numeric_fail",),
+    "_bj_lcd_cursor_row": ("_bj_numeric_fail",),
+    "_bj_positive_int": ("_bj_numeric_fail",),
+    "_bj_servo_angle": ("_bj_numeric_fail",),
+    "_bj_servo_pulse": ("_bj_numeric_fail",),
+    "_bj_servo_attach_bounds": ("_bj_numeric_fail",),
+    "_bj_digital_pin": ("_bj_numeric_fail",),
+    "_bj_pwm_pin": ("_bj_numeric_fail",),
+    "_bj_analog_pin": ("_bj_numeric_fail",),
+    "_bj_time_threshold": ("_bj_numeric_fail",),
+    "_bj_float_to_i32": ("_bj_numeric_fail",),
+    "_bj_round_i32": ("_bj_round_even_f32", "_bj_numeric_fail"),
+    "_bj_round_f32_digits": (
+        "_bj_round_ratio_even_u64", "_bj_round_pow2_even_u64", "_bj_ratio_to_f32", "_bj_numeric_fail",
+    ),
+    "_bj_round_i32_digits": ("_bj_numeric_fail",),
+    "_bj_i32_abs": ("_bj_numeric_fail",),
+}
+
+
+def _package_version() -> str:
+    from .. import __version__
+    return __version__
+
+
+def _helper_name(line: str) -> str:
+    """Name of a `static ... _bj_name(` helper definition line (attributes allowed)."""
+    match = re.search(r"\b(_bj_\w+)\s*\(", line)
+    if match is None:
+        raise InternalCompilerError(f"Malformed backend helper definition: {line!r}")
+    return match.group(1)
+
+
+def _split_helper_blob(blob: str) -> dict[str, str]:
+    lines = blob.splitlines()
+    result: dict[str, str] = {}
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        if not line.startswith("static "):
+            i += 1
+            continue
+        name = _helper_name(line)
+        depth = 0
+        block: list[str] = []
+        while i < len(lines):
+            current = lines[i]
+            block.append(current)
+            depth += current.count("{") - current.count("}")
+            i += 1
+            if depth == 0:
+                break
+        result[name] = "\n".join(block)
+    return result
+
+
+# Helpers for the upload-only Arduino core additions in V1.1 Stage 1.
+_NUMERIC_HELPER_BLOB += r'''
+static uint16_t _bj_tone_frequency(int32_t hz) {
+    if (hz < 31 || hz > 65535) _bj_numeric_fail();
+    return (uint16_t)hz;
+}
+static uint16_t _bj_delay_us(int32_t microseconds) {
+    if (microseconds < 0 || microseconds > 16383) _bj_numeric_fail();
+    return (uint16_t)microseconds;
+}
+static int32_t _bj_constrain_int(int32_t value, int32_t low, int32_t high) {
+    if (low > high) _bj_numeric_fail();
+    return value < low ? low : (value > high ? high : value);
+}
+static int32_t _bj_arduino_map(int32_t value, int32_t in_min, int32_t in_max, int32_t out_min, int32_t out_max) {
+    int64_t den = (int64_t)in_max - (int64_t)in_min;
+    if (!den) _bj_numeric_fail();
+    int64_t left = (int64_t)value - (int64_t)in_min;
+    int64_t right = (int64_t)out_max - (int64_t)out_min;
+    // Arduino map() truncates division toward zero. Using 64-bit intermediates
+    // avoids the usual 32-bit overflow in classroom joystick mappings.
+    // Reject extreme inputs that cannot be represented safely as signed 64-bit.
+    uint64_t a = left < 0 ? (uint64_t)(-left) : (uint64_t)left;
+    uint64_t b = right < 0 ? (uint64_t)(-right) : (uint64_t)right;
+    if (b && a > 9223372036854775807ULL / b) _bj_numeric_fail();
+    int64_t num = left * right;
+    int64_t result = num / den + (int64_t)out_min;
+    if (result < -2147483648LL || result > 2147483647LL) _bj_numeric_fail();
+    return (int32_t)result;
+}
+'''
+_HELPER_DEPS.update({
+    "_bj_tone_frequency": ("_bj_numeric_fail",),
+    "_bj_delay_us": ("_bj_numeric_fail",),
+    "_bj_constrain_int": ("_bj_numeric_fail",),
+    "_bj_arduino_map": ("_bj_numeric_fail",),
+})
+_HELPER_BLOCKS = _split_helper_blob(_NUMERIC_HELPER_BLOB)
+
+
+_PIN_GUARDS = {
+    "pinMode": "_bj_digital_pin", "digitalWrite": "_bj_digital_pin", "digitalRead": "_bj_digital_pin",
+    "analogWrite": "_bj_pwm_pin", "analogRead": "_bj_analog_pin", "tone": "_bj_digital_pin", "noTone": "_bj_digital_pin",
+}
+_PIN_SETS = {
+    "_bj_digital_pin": frozenset(range(20)),
+    "_bj_pwm_pin": frozenset({3, 5, 6, 9, 10, 11}),
+    "_bj_analog_pin": frozenset(set(range(6)) | set(range(14, 20))),
+}
+
+
+def _helper_closure(names: set[str]) -> set[str]:
+    closure = set(names); changed = True
+    while changed:
+        changed = False
+        for name in tuple(closure):
+            for dep in _HELPER_DEPS.get(name, ()):
+                if dep not in closure: closure.add(dep); changed = True
+    return closure
+
+
+def _walk(value: Any):
+    yield value
+    if is_dataclass(value):
+        for f in fields(value):
+            yield from _walk(getattr(value, f.name))
+    elif isinstance(value, (tuple, list, frozenset)):
+        for item in value:
+            yield from _walk(item)
+    elif isinstance(value, dict):
+        for key, item in value.items():
+            yield from _walk(key)
+            yield from _walk(item)
+
+
+class UnoCppBackend:
+    """Phase-H backend. Its only semantic inputs are typed IR + TargetPlan."""
+
+    def __init__(self, ir_module: IRModule, target_plan: TargetPlan) -> None:
+        validate_ir(ir_module)
+        if target_plan.ir_module is not ir_module and target_plan.ir_module != ir_module:
+            raise InternalCompilerError("TargetPlan does not belong to the supplied typed IR module.")
+        self.ir = ir_module
+        self.target = target_plan
+        self._temp_counter = 0
+        self._temp_names: dict[object, str] = {}
+        self._storage = {decl.symbol.symbol_id: decl for decl in ir_module.storages}
+        self._objects = {obj.symbol.symbol_id: obj for obj in ir_module.objects}
+        self._hoisted_stmt_ids: set[int] = set()
+        self._dynamic_helpers: set[str] = set()
+        self._constant_symbol_values: dict[object, int] = {}
+        # Range facts are derived only from typed IR. They let the backend
+        # omit redundant runtime guards without reaching back into numeric AST analysis.
+        self._active_int_ranges: dict[object, tuple[int, int]] = {}
+        self._safe_pwm_call_ids: set[int] = self._find_range_proven_pwm_calls()
+
+    def _find_range_proven_pwm_calls(self) -> set[int]:
+        safe: set[int] = set()
+
+        def visit_expr(expr: IRExpr, ranges: dict[object, tuple[int, int]]) -> None:
+            if isinstance(expr, IRCall):
+                if (expr.kind == IRCallKind.API_FUNCTION and expr.name == "analogWrite"
+                        and len(expr.args) >= 2 and self._known_pwm_safe(expr.args[1], ranges)):
+                    safe.add(id(expr))
+            if is_dataclass(expr):
+                for f in fields(expr):
+                    value = getattr(expr, f.name)
+                    if isinstance(value, IRExpr):
+                        visit_expr(value, ranges)
+                    elif isinstance(value, (tuple, list)):
+                        for item in value:
+                            if isinstance(item, IRExpr):
+                                visit_expr(item, ranges)
+                            elif isinstance(item, IRFormattedValue):
+                                visit_expr(item.value, ranges)
+
+        def visit_stmt(stmt: IRStmt, ranges: dict[object, tuple[int, int]]) -> None:
+            local = ranges
+            if isinstance(stmt, IRRangeLoop):
+                facts = self._constant_range_bounds(stmt)
+                body_ranges = dict(ranges)
+                if facts is not None and not self._body_writes(stmt.body, stmt.target.symbol_id, stmt.target.kind != SymbolKind.LOCAL):
+                    body_ranges[stmt.target.symbol_id] = facts
+                visit_expr(stmt.start, ranges); visit_expr(stmt.stop, ranges); visit_expr(stmt.step, ranges)
+                for child in stmt.body:
+                    visit_stmt(child, body_ranges)
+                return
+            if isinstance(stmt, IRIf):
+                visit_expr(stmt.condition, ranges)
+                for child in stmt.body: visit_stmt(child, dict(ranges))
+                for child in stmt.otherwise: visit_stmt(child, dict(ranges))
+                return
+            if isinstance(stmt, IRWhile):
+                visit_expr(stmt.condition, ranges)
+                for child in stmt.body: visit_stmt(child, dict(ranges))
+                return
+            if isinstance(stmt, IRFixedListLoop):
+                if stmt.index_start is not None: visit_expr(stmt.index_start, ranges)
+                for child in stmt.body: visit_stmt(child, dict(ranges))
+                return
+            if is_dataclass(stmt):
+                for f in fields(stmt):
+                    value = getattr(stmt, f.name)
+                    if isinstance(value, IRExpr): visit_expr(value, local)
+                    elif isinstance(value, (tuple, list)):
+                        for item in value:
+                            if isinstance(item, IRExpr): visit_expr(item, local)
+
+        for stmt in self.ir.setup: visit_stmt(stmt, {})
+        for stmt in self.ir.main_loop: visit_stmt(stmt, {})
+        for fn in self.ir.functions:
+            for stmt in fn.body: visit_stmt(stmt, {})
+        return safe
+
+    @staticmethod
+    def _body_writes(body, symbol_id, global_symbol: bool = True) -> bool:
+        for item in _walk(body):
+            if isinstance(item, (IRStore, IRAugStore)) and item.target.symbol_id == symbol_id:
+                return True
+            if isinstance(item, IRRangeLoop) and item.target.symbol_id == symbol_id:
+                return True
+            if isinstance(item, IRFixedListLoop) and (item.value_target.symbol_id == symbol_id or (item.index_target is not None and item.index_target.symbol_id == symbol_id)):
+                return True
+            if global_symbol and isinstance(item, IRCall) and item.kind == IRCallKind.USER_FUNCTION:
+                return True  # a called function may write a module-level loop variable
+        return False
+
+    def _constant_range_bounds(self, stmt: IRRangeLoop) -> tuple[int, int] | None:
+        start, stop, step = self._const_int(stmt.start), self._const_int(stmt.stop), self._const_int(stmt.step)
+        if start is None or stop is None or step in (None, 0):
+            return None
+        if step > 0:
+            if start >= stop: return None
+            last = start + ((stop - 1 - start) // step) * step
+            return (start, last)
+        if start <= stop: return None
+        last = start + ((start - (stop + 1)) // (-step)) * step
+        return (last, start)
+
+    def generate(self) -> GeneratedSketch:
+        helper_names = self._required_numeric_helpers()
+        if self._needs_python_float_formatter():
+            # The exact float32 shortest-repr formatter reuses the exact rational helpers.
+            helper_names |= {"_bj_round_ratio_even_u64", "_bj_round_pow2_even_u64", "_bj_ratio_to_f32", "_bj_numeric_fail"}
+        parts: list[tuple[str, SourceSpan | None]] = []
+        add = parts.append
+
+        add((f"// Generated by Barmaja PyArduino {_package_version()}", None))
+        add(("// Edit the Python source, not this generated file.", None))
+        for header in self.target.includes:
+            add((f"#include <{header}>", None))
+        add(("", None))
+
+        # Arduino's .ino preprocessor synthesizes prototypes before the first function
+        # definition. Helper-owned types therefore MUST appear before every helper
+        # function; otherwise ctags can place prototypes above their typedefs (F7).
+        if self._needs_python_float_formatter():
+            add((_OUTPUT_HELPER_PREAMBLE, None))
+            add(("", None))
+
+        # Helpers are inserted here after the body is generated, so runtime guards
+        # chosen during generation (delay/servo/timeout) are emitted exactly when used.
+        helper_insert_at = len(parts)
+
+        hoisted = self._find_hoistable_setup_stores()
+        # Module constants initialized statically have exactly one known value.
+        for sid, store in hoisted.items():
+            decl = self._storage.get(sid)
+            value = self._const_int(store.value)
+            if decl is not None and decl.storage == StorageClass.MODULE_CONSTANT and value is not None:
+                self._constant_symbol_values[sid] = value
+        emitted_globals = False
+        for decl in self.ir.storages:
+            if decl.storage not in {StorageClass.MODULE_CONSTANT, StorageClass.PERSISTENT_MODULE}:
+                continue
+            emitted_globals = True
+            init_stmt = hoisted.get(decl.symbol.symbol_id)
+            if init_stmt is not None:
+                self._hoisted_stmt_ids.add(id(init_stmt))
+                value = init_stmt.value
+                if decl.symbol.type.kind == TypeKind.FIXED_LIST:
+                    if not isinstance(value, IRListLiteral):
+                        raise InternalCompilerError("Fixed-list static initializer is not an IR list literal.")
+                    elem = decl.symbol.type.element_type
+                    if elem is None or decl.symbol.type.length is None:
+                        raise InternalCompilerError("Incomplete fixed-list type reached Uno backend.")
+                    items = ", ".join(self._expr(x) for x in value.elements)
+                    if decl.storage == StorageClass.MODULE_CONSTANT:
+                        # `const char*` elements: make the pointers const (`const char* const`),
+                        # never the ill-formed `const const char*`.
+                        elem_decl = f"{elem.cpp_type} const" if elem.cpp_type.startswith("const ") else f"const {elem.cpp_type}"
+                    else:
+                        elem_decl = elem.cpp_type
+                    add((f"{elem_decl} {decl.symbol.backend_name}[{decl.symbol.type.length}] = {{{items}}};", decl.span))
+                else:
+                    typ = decl.symbol.type.cpp_type
+                    dtype = ("const char* const" if typ == "const char*" else f"const {typ}") if decl.storage == StorageClass.MODULE_CONSTANT else typ
+                    add((f"{dtype} {decl.symbol.backend_name} = {self._expr(value)};", decl.span))
+            else:
+                add((self._decl_line(decl.symbol), decl.span))
+        if emitted_globals:
+            add(("", None))
+
+        ctor_values = dict(self.target.object_arg_values)
+        for obj in self.ir.objects:
+            args = ", ".join(self._ctor_arg(a, v) for a, v in zip(obj.args, ctor_values.get(obj.symbol.symbol_id, (None,) * len(obj.args))))
+            # Arduino Ethernet.h declares EthernetW5500 as a global enum value.
+            # Keep the public Python hardware-class name, but emit our uniquely
+            # named C++ adapter type to avoid collision with the Arduino library.
+            cpp_class_name = "BarmajaEthernetW5500" if obj.class_name == "EthernetW5500" else obj.class_name
+            text = f"{cpp_class_name} {obj.symbol.backend_name}({args});" if args else f"{cpp_class_name} {obj.symbol.backend_name};"
+            add((text, obj.span))
+        if self.ir.objects:
+            add(("", None))
+
+        for fn in self.ir.functions:
+            params = ", ".join(f"{p.type.cpp_type} {p.backend_name}" for p in fn.parameters)
+            add((f"{fn.return_type.cpp_type} {fn.symbol.backend_name}({params});", fn.span))
+        if self.ir.functions:
+            add(("", None))
+
+        for fn in self.ir.functions:
+            parts.extend(self._function(fn))
+            add(("", None))
+
+        add(("void setup() {", None))
+        for decl in self.ir.storages:
+            if decl.storage == StorageClass.SETUP_LOCAL:
+                add(("    " + self._decl_line(decl.symbol, local=True), decl.span))
+        for hook in self.target.setup_hooks:
+            add(("    " + hook, None))
+        for stmt in self.ir.setup:
+            if id(stmt) in self._hoisted_stmt_ids:
+                continue
+            parts.extend(self._stmt(stmt, 1))
+        add(("}", None))
+        add(("", None))
+
+        add(("void loop() {", None))
+        for decl in self.ir.storages:
+            if decl.storage == StorageClass.LOOP_TEMPORARY:
+                add(("    " + self._decl_line(decl.symbol, local=True), decl.span))
+        for stmt in self.ir.main_loop:
+            parts.extend(self._stmt(stmt, 1))
+        add(("}", None))
+        add(("", None))
+
+        helper_names = _helper_closure(helper_names | self._dynamic_helpers)
+        helper_lines: list[tuple[str, SourceSpan | None]] = []
+        if helper_names:
+            for name in self._helper_order(helper_names):
+                block = _HELPER_BLOCKS.get(name)
+                if block is None:
+                    raise InternalCompilerError(f"Backend helper '{name}' is not defined.")
+                helper_lines.extend((line, None) for line in block.splitlines())
+            helper_lines.append(("", None))
+        if self._needs_python_float_formatter():
+            helper_lines.extend((line, None) for line in _OUTPUT_HELPER_BLOB.splitlines())
+            helper_lines.append(("", None))
+        if self._needs_fixed_float_formatter():
+            helper_lines.extend((line, None) for line in _FIXED_HELPER_BLOB.splitlines())
+            helper_lines.append(("", None))
+        parts[helper_insert_at:helper_insert_at] = helper_lines
+
+        cpp_lines = [text for text, _ in parts]
+        source_map = tuple(
+            SourceMapEntry(index + 1, self.ir.source_name, span)
+            for index, (_, span) in enumerate(parts) if span is not None
+        )
+        return GeneratedSketch(
+            cpp="\n".join(cpp_lines),
+            source_map=source_map,
+            dependency_ids=self.target.dependency_ids,
+            resolved_serial_baud=self.target.resolved_serial_baud,
+            diagnostics=self.target.diagnostics,
+        )
+
+    def _ctor_arg(self, arg: IRExpr, value: int | None) -> str:
+        """Hardware objects are constructed before setup(); never reference setup-time storage."""
+        if isinstance(arg, IRConstant) or (isinstance(arg, IRLoad) and arg.symbol.kind in {SymbolKind.API, SymbolKind.BUILTIN}):
+            return self._expr(arg)
+        if value is None:
+            raise InternalCompilerError("Hardware constructor argument reached the backend without a proven compile-time value.")
+        return str(value)
+
+    def _find_hoistable_setup_stores(self) -> dict[object, IRStore]:
+        """Find setup stores that may become file-scope static initializers.
+
+        A store is only hoisted when it is the first write of that symbol in
+        execution order. Any earlier setup statement that may write the symbol
+        (nested stores, loop targets, augmented/index stores, or a user-function
+        call that could write globals) blocks hoisting, because moving the store
+        before those writes would change the program's result.
+        """
+        result: dict[object, IRStore] = {}
+        written: set[object] = set()
+        opaque_call_seen = False
+        for stmt in self.ir.setup:
+            if isinstance(stmt, IRStore):
+                sid = stmt.target.symbol_id
+                decl = self._storage.get(sid)
+                if (
+                    decl is not None
+                    and decl.storage in {StorageClass.MODULE_CONSTANT, StorageClass.PERSISTENT_MODULE}
+                    and sid not in written
+                    and sid not in result
+                    and (decl.storage == StorageClass.MODULE_CONSTANT or not opaque_call_seen)
+                    and self._is_static_initializer(stmt.value)
+                    and not (stmt.target.type.kind == TypeKind.TIME_U32 and not self._known_nonnegative_int(stmt.value))
+                ):
+                    result[sid] = stmt
+            for item in _walk(stmt):
+                if isinstance(item, (IRStore, IRAugStore)):
+                    written.add(item.target.symbol_id)
+                elif isinstance(item, IRIndexStore):
+                    written.add(item.collection.symbol_id)
+                elif isinstance(item, IRRangeLoop):
+                    written.add(item.target.symbol_id)
+                elif isinstance(item, IRFixedListLoop):
+                    written.add(item.value_target.symbol_id)
+                    if item.index_target is not None:
+                        written.add(item.index_target.symbol_id)
+                elif isinstance(item, IRCall) and item.kind == IRCallKind.USER_FUNCTION:
+                    opaque_call_seen = True
+        return result
+
+    def _is_static_initializer(self, expr: IRExpr) -> bool:
+        if isinstance(expr, IRConstant):
+            return True
+        if isinstance(expr, IRUnary) and expr.op == IRUnaryOp.NEGATE and isinstance(expr.operand, IRConstant):
+            return True
+        if isinstance(expr, IRListLiteral):
+            return all(self._is_static_initializer(x) for x in expr.elements)
+        return False
+
+    @staticmethod
+    def _decl_line(symbol: IRSymbolRef, *, local: bool = False) -> str:
+        typ = symbol.type
+        if typ.kind == TypeKind.FIXED_LIST:
+            if typ.element_type is None or typ.length is None:
+                raise InternalCompilerError("Incomplete fixed-list type reached declaration generation.")
+            # A fixed list inside setup()/loop()/a function would otherwise live on the
+            # 2 KB AVR stack, invisible to both the static SRAM estimate and the
+            # linker's "Global variables" figure.  Static storage is safe here: V1
+            # forbids recursion and every local list is definitely assigned before use.
+            storage = "static " if local else ""
+            return f"{storage}{typ.element_type.cpp_type} {symbol.backend_name}[{typ.length}];"
+        return f"{typ.cpp_type} {symbol.backend_name};"
+
+    def _function(self, fn: IRFunction) -> list[tuple[str, SourceSpan | None]]:
+        params = ", ".join(f"{p.type.cpp_type} {p.backend_name}" for p in fn.parameters)
+        out: list[tuple[str, SourceSpan | None]] = [(f"{fn.return_type.cpp_type} {fn.symbol.backend_name}({params}) {{", fn.span)]
+        for symbol in self._function_locals(fn):
+            out.append(("    " + self._decl_line(symbol, local=True), fn.span))
+        for stmt in fn.body:
+            out.extend(self._stmt(stmt, 1))
+        out.append(("}", fn.span))
+        return out
+
+    def _function_locals(self, fn: IRFunction) -> list[IRSymbolRef]:
+        params = {p.symbol_id for p in fn.parameters}
+        module_ids = set(self._storage) | set(self._objects)
+        found: dict[object, IRSymbolRef] = {}
+        for item in _walk(fn.body):
+            refs: list[IRSymbolRef] = []
+            if isinstance(item, (IRStore, IRAugStore)):
+                refs.append(item.target)
+            elif isinstance(item, IRFixedListLoop):
+                refs.append(item.value_target)
+                if item.index_target is not None:
+                    refs.append(item.index_target)
+            elif isinstance(item, IRRangeLoop):
+                refs.append(item.target)
+            for ref in refs:
+                if ref.symbol_id not in params and ref.symbol_id not in module_ids and ref.kind == SymbolKind.LOCAL:
+                    found.setdefault(ref.symbol_id, ref)
+        return sorted(found.values(), key=lambda s: s.symbol_id.value)
+
+    def _aug_store_lines(self, stmt: IRAugStore, pad: str, span, current: str, rhs: str) -> list[tuple[str, SourceSpan | None]]:
+        name = stmt.target.backend_name
+        kind = stmt.target.type.kind
+        if stmt.op == IRBinaryOp.TRUE_DIVIDE:
+            return [(f"{pad}{name} = _bj_true_div_f32((float)({current}), (float)({rhs}));", span)]
+        if stmt.op == IRBinaryOp.MODULO:
+            if kind == TypeKind.FLOAT:
+                return [(f"{pad}{name} = _bj_mod_f32((float)({current}), (float)({rhs}));", span)]
+            return [(f"{pad}{name} = _bj_mod_i32({current}, {rhs});", span)]
+        if kind == TypeKind.INT and stmt.op in {IRBinaryOp.ADD, IRBinaryOp.SUBTRACT, IRBinaryOp.MULTIPLY}:
+            helper = {IRBinaryOp.ADD:"_bj_i32_add", IRBinaryOp.SUBTRACT:"_bj_i32_sub", IRBinaryOp.MULTIPLY:"_bj_i32_mul"}[stmt.op]
+            return [(f"{pad}{name} = {helper}({current}, {rhs});", span)]
+        op = {IRBinaryOp.ADD:"+", IRBinaryOp.SUBTRACT:"-", IRBinaryOp.MULTIPLY:"*"}.get(stmt.op)
+        if op is None:
+            raise InternalCompilerError("Unsupported augmented IR operator reached Uno backend.")
+        return [(f"{pad}{name} = ({current} {op} {rhs});", span)]
+
+    def _stmt(self, stmt: IRStmt, indent: int) -> list[tuple[str, SourceSpan | None]]:
+        pad = "    " * indent
+        span = stmt.span
+        if isinstance(stmt, IRStore):
+            if stmt.target.type.kind == TypeKind.FIXED_LIST:
+                if not isinstance(stmt.value, IRListLiteral):
+                    raise InternalCompilerError("Whole fixed-list store reached backend without IRListLiteral.")
+                elements = stmt.value.elements
+                if all(isinstance(v, IRConstant) for v in elements):
+                    return [(f"{pad}{stmt.target.backend_name}[{i}] = {self._expr(v)};", span) for i, v in enumerate(elements)]
+                # Python evaluates the whole list literal (left to right) before
+                # rebinding: `L = [x, L[0], L[1]]` must read the OLD elements.
+                # Materialize every element first, then store.
+                elem_type = stmt.target.type.element_type
+                if elem_type is None:
+                    raise InternalCompilerError("Incomplete fixed-list type reached Uno backend.")
+                temps = [self._new_temp("list_elem") for _ in elements]
+                out = [(f"{pad}{elem_type.cpp_type} {t} = {self._expr(v)};", span) for t, v in zip(temps, elements)]
+                out.extend((f"{pad}{stmt.target.backend_name}[{i}] = {t};", span) for i, t in enumerate(temps))
+                return out
+            value = self._expr(stmt.value)
+            if stmt.target.type.kind == TypeKind.TIME_U32 and stmt.value.type.kind == TypeKind.INT and not self._known_nonnegative_int(stmt.value):
+                value = f"_bj_time_threshold({value})"; self._dynamic_helpers.add("_bj_time_threshold")
+            return [(f"{pad}{stmt.target.backend_name} = {value};", span)]
+        if isinstance(stmt, IRIndexStore):
+            if self._expr_has_effects(stmt.value):
+                # Python evaluates the right-hand side before the subscript target.
+                value_tmp = self._new_temp("store_value")
+                value_line = f"{pad}{stmt.value.type.cpp_type} {value_tmp} = {self._expr(stmt.value)};"
+                index = self._list_index_expr(stmt.index, stmt.collection.type)
+                return [(value_line, span), (f"{pad}{stmt.collection.backend_name}[{index}] = {value_tmp};", span)]
+            index = self._list_index_expr(stmt.index, stmt.collection.type)
+            return [(f"{pad}{stmt.collection.backend_name}[{index}] = {self._expr(stmt.value)};", span)]
+        if isinstance(stmt, IRAugStore):
+            name = stmt.target.backend_name
+            rhs = self._expr(stmt.value)
+            prefix: list[tuple[str, SourceSpan | None]] = []
+            if self._expr_has_effects(stmt.value):
+                # Python reads the target before evaluating the right-hand side.
+                old_tmp = self._new_temp("aug_target")
+                rhs_tmp = self._new_temp("aug_value")
+                prefix = [
+                    (f"{pad}{stmt.target.type.cpp_type} {old_tmp} = {name};", span),
+                    (f"{pad}{stmt.value.type.cpp_type} {rhs_tmp} = {rhs};", span),
+                ]
+                return prefix + self._aug_store_lines(stmt, pad, span, old_tmp, rhs_tmp)
+            return self._aug_store_lines(stmt, pad, span, name, rhs)
+        if isinstance(stmt, IRExprStmt):
+            special = self._explicit_output_stmt(stmt.expression, indent)
+            if special is not None:
+                return [(line, span) for line in special]
+            return [(f"{pad}{self._expr(stmt.expression)};", span)]
+        if isinstance(stmt, IRPrint):
+            return [(line, span) for line in self._python_print(stmt, indent)]
+        if isinstance(stmt, IRReturn):
+            return [(pad + ("return;" if stmt.value is None else f"return {self._expr(stmt.value)};"), span)]
+        if isinstance(stmt, IRBreak):
+            if stmt.target == IRLoopControlTarget.MAIN_LOOP:
+                raise InternalCompilerError("A main-loop break reached the Uno backend after validation.")
+            return [(pad + "break;", span)]
+        if isinstance(stmt, IRContinue):
+            return [(pad + ("return;" if stmt.target == IRLoopControlTarget.MAIN_LOOP else "continue;"), span)]
+        if isinstance(stmt, IRIf):
+            out = [(f"{pad}if ({self._expr(stmt.condition)}) {{", span)]
+            for child in stmt.body:
+                out.extend(self._stmt(child, indent + 1))
+            out.append((pad + "}", span))
+            if stmt.otherwise:
+                out[-1] = (out[-1][0] + " else {", span)
+                for child in stmt.otherwise:
+                    out.extend(self._stmt(child, indent + 1))
+                out.append((pad + "}", span))
+            return out
+        if isinstance(stmt, IRWhile):
+            out = [(f"{pad}while ({self._expr(stmt.condition)}) {{", span)]
+            for child in stmt.body:
+                out.extend(self._stmt(child, indent + 1))
+            out.append((pad + "}", span))
+            return out
+        if isinstance(stmt, IRRangeLoop):
+            start = self._temp_name(stmt.start_temp, "range_start")
+            stop = self._temp_name(stmt.stop_temp, "range_stop")
+            step = self._temp_name(stmt.step_temp, "range_step")
+            iterator = self._temp_name(stmt.iterator_temp, "range_iter")
+            out = [
+                (f"{pad}int32_t {start} = {self._expr(stmt.start)};", span),
+                (f"{pad}int32_t {stop} = {self._expr(stmt.stop)};", span),
+                (f"{pad}int32_t {step} = {self._expr(stmt.step)};", span),
+            ]
+            step_value = self._const_int(stmt.step)
+            if step_value == 0:
+                raise InternalCompilerError("A zero range step reached the Uno backend after validation.")
+            if step_value is None:
+                out.append((f"{pad}if ({step} == 0) _bj_numeric_fail();", span))
+                cond = f"({step} > 0 ? {iterator} < {stop} : {iterator} > {stop})"
+            else:
+                cond = f"{iterator} {'<' if step_value > 0 else '>'} {stop}"
+            # Python range() never computes a value past the final element, but a C++
+            # for-loop does evaluate `iterator + step` once more.  Near INT32_MAX/MIN
+            # that final increment must not be an Int32 overflow trap (or UB), so the
+            # iterator is widened unless the whole progression is statically in range.
+            bounds = self._constant_range_bounds(stmt)
+            iterator_type = "int64_t"
+            if bounds is not None and step_value is not None:
+                after_last = (bounds[1] + step_value) if step_value > 0 else (bounds[0] + step_value)
+                if -(2**31) <= after_last <= 2**31 - 1:
+                    iterator_type = "int32_t"
+            elif (
+                step_value is not None
+                and self._const_int(stmt.start) is not None
+                and self._const_int(stmt.stop) is not None
+            ):
+                # Constant but empty progression: the body never runs.
+                iterator_type = "int32_t"
+            out.append((f"{pad}for ({iterator_type} {iterator} = {start}; {cond}; {iterator} += {step}) {{", span))
+            narrow = "(int32_t)" if iterator_type == "int64_t" else ""
+            out.append((f"{pad}    {stmt.target.backend_name} = {narrow}{iterator};", span))
+            previous = self._active_int_ranges.get(stmt.target.symbol_id)
+            facts = self._constant_range_bounds(stmt)
+            if facts is not None and not self._body_writes(stmt.body, stmt.target.symbol_id, stmt.target.kind != SymbolKind.LOCAL):
+                self._active_int_ranges[stmt.target.symbol_id] = facts
+            else:
+                # The loop variable is reassigned in the body: its range is not proven.
+                self._active_int_ranges.pop(stmt.target.symbol_id, None)
+            try:
+                for child in stmt.body:
+                    out.extend(self._stmt(child, indent + 1))
+            finally:
+                if previous is None:
+                    self._active_int_ranges.pop(stmt.target.symbol_id, None)
+                else:
+                    self._active_int_ranges[stmt.target.symbol_id] = previous
+            out.append((pad + "}", span))
+            return out
+        if isinstance(stmt, IRFixedListLoop):
+            typ = stmt.collection.type
+            if typ.kind != TypeKind.FIXED_LIST or typ.length is None:
+                raise InternalCompilerError("Fixed-list loop reached Uno backend without fixed-list type.")
+            iterator = self._temp_name(stmt.iterator_temp, "list_iter")
+            out: list[tuple[str, SourceSpan | None]] = []
+            start_name: str | None = None
+            if stmt.index_start is not None:
+                if stmt.index_start_temp is None:
+                    raise InternalCompilerError("enumerate(start) IR is missing its evaluate-once temporary.")
+                start_name = self._temp_name(stmt.index_start_temp, "enumerate_start")
+                out.append((f"{pad}int32_t {start_name} = {self._expr(stmt.index_start)};", span))
+            out.append((f"{pad}for (int32_t {iterator} = 0; {iterator} < {typ.length}; ++{iterator}) {{", span))
+            if stmt.index_target is not None:
+                if start_name is None:
+                    out.append((f"{pad}    {stmt.index_target.backend_name} = {iterator};", span))
+                else:
+                    out.append((f"{pad}    {stmt.index_target.backend_name} = _bj_i32_add({start_name}, {iterator});", span))
+            out.append((f"{pad}    {stmt.value_target.backend_name} = {stmt.collection.backend_name}[{iterator}];", span))
+            for child in stmt.body:
+                out.extend(self._stmt(child, indent + 1))
+            out.append((pad + "}", span))
+            return out
+        raise InternalCompilerError(f"Unsupported typed IR statement {type(stmt).__name__} reached Uno backend.")
+
+    def _expr(self, expr: IRExpr) -> str:
+        if isinstance(expr, IRConstant):
+            if expr.value is True: return "true"
+            if expr.value is False: return "false"
+            if isinstance(expr.value, str): return self._cpp_string_literal(expr.value)
+            return repr(expr.value)
+        if isinstance(expr, IRLoad):
+            if expr.symbol.kind in {SymbolKind.API, SymbolKind.BUILTIN}:
+                return expr.symbol.source_name
+            return expr.symbol.backend_name
+        if isinstance(expr, IRListLiteral):
+            return "{" + ", ".join(self._expr(x) for x in expr.elements) + "}"
+        if isinstance(expr, IRIndex):
+            if not isinstance(expr.collection, IRLoad):
+                raise InternalCompilerError("Fixed-list IR index has no direct list load.")
+            return f"{self._expr(expr.collection)}[{self._list_index_expr(expr.index, expr.collection.type)}]"
+        if isinstance(expr, IRUnary):
+            operand = self._expr(expr.operand)
+            if expr.op == IRUnaryOp.NOT:
+                return f"(!{operand})"
+            if isinstance(expr.operand, IRConstant) and expr.operand.value == 2**31:
+                return "(-2147483647L - 1L)"
+            if expr.type.kind == TypeKind.INT and IREffect.MAY_FAIL in expr.effects:
+                return f"_bj_i32_neg({operand})"
+            return f"(-{operand})"
+        if isinstance(expr, IRBinary):
+            return self._binary_expr(expr)
+        if isinstance(expr, IRCompareChain):
+            return self._comparison_expr(expr)
+        if isinstance(expr, IRBool):
+            op = " && " if expr.op == IRBoolOp.AND else " || "
+            return "(" + op.join(self._expr(x) for x in expr.values) + ")"
+        if isinstance(expr, IRConditional):
+            return f"({self._expr(expr.condition)} ? {self._expr(expr.when_true)} : {self._expr(expr.when_false)})"
+        if isinstance(expr, IRCall):
+            return self._call(expr)
+        if isinstance(expr, IRFormatString):
+            raise InternalCompilerError("Output-only f-string reached scalar expression generation.")
+        raise InternalCompilerError(f"Unsupported typed IR expression {type(expr).__name__} reached Uno backend.")
+
+    def _binary_expr(self, expr: IRBinary) -> str:
+        left, right = self._expr(expr.left), self._expr(expr.right)
+        def operation(a: str, b: str) -> str:
+            if expr.type.kind == TypeKind.TIME_U32 and expr.op == IRBinaryOp.SUBTRACT:
+                return f"((uint32_t)({a}) - (uint32_t)({b}))"
+            if expr.op == IRBinaryOp.TRUE_DIVIDE:
+                return f"_bj_true_div_f32((float)({a}), (float)({b}))"
+            if expr.op == IRBinaryOp.MODULO:
+                return f"_bj_mod_f32((float)({a}), (float)({b}))" if expr.type.kind == TypeKind.FLOAT else f"_bj_mod_i32({a}, {b})"
+            if expr.type.kind == TypeKind.INT and expr.checked:
+                helper = {IRBinaryOp.ADD:"_bj_i32_add", IRBinaryOp.SUBTRACT:"_bj_i32_sub", IRBinaryOp.MULTIPLY:"_bj_i32_mul"}.get(expr.op)
+                if helper is not None: return f"{helper}({a}, {b})"
+            op = {IRBinaryOp.ADD:"+", IRBinaryOp.SUBTRACT:"-", IRBinaryOp.MULTIPLY:"*"}.get(expr.op)
+            if op is None: raise InternalCompilerError("Unknown binary IR operation reached backend.")
+            return f"({a} {op} {b})"
+        if self._expr_has_effects(expr.left) or self._expr_has_effects(expr.right):
+            ltmp = self._new_temp("lhs"); rtmp = self._new_temp("rhs")
+            return f"([&]() -> {expr.type.cpp_type} {{ {expr.left.type.cpp_type} {ltmp} = {left}; {expr.right.type.cpp_type} {rtmp} = {right}; return {operation(ltmp, rtmp)}; }}())"
+        if (
+            expr.type.kind == TypeKind.INT
+            and not expr.checked
+            and expr.op in {IRBinaryOp.ADD, IRBinaryOp.SUBTRACT, IRBinaryOp.MULTIPLY}
+            and not self._is_int32_storage_load(expr.left)
+            and not self._is_int32_storage_load(expr.right)
+        ):
+            # AVR `int` is 16 bits: `1000 * 60` or `32767 + 29` written with C++ int
+            # literals/Arduino macros would be computed (and overflow) in 16 bits even
+            # though Barmaja proved the Python result fits Int32.  Force Int32 arithmetic.
+            left = f"(int32_t)({left})"
+        return operation(left, right)
+
+    @staticmethod
+    def _is_int32_storage_load(expr: IRExpr) -> bool:
+        """True when the emitted C++ expression already has type int32_t."""
+        if expr.type.kind != TypeKind.INT:
+            return False
+        if isinstance(expr, IRLoad):
+            return expr.symbol.kind not in {SymbolKind.API, SymbolKind.BUILTIN}
+        if isinstance(expr, IRBinary):
+            # checked helpers return int32_t; unchecked ADD/SUB/MUL are widened here;
+            # modulo uses _bj_mod_i32 (int32_t).
+            return True
+        if isinstance(expr, IRIndex):
+            return True  # element of an int32_t fixed-list array
+        if isinstance(expr, IRCall) and expr.kind == IRCallKind.USER_FUNCTION:
+            return True  # user functions returning Int are declared int32_t
+        return False
+
+    def _comparison_expr(self, expr: IRCompareChain) -> str:
+        names = [self._temp_name(t, "cmp") for t in expr.operand_temps]
+        pieces = [f"{expr.operands[0].type.cpp_type} {names[0]} = {self._expr(expr.operands[0])};"]
+        for i, op in enumerate(expr.operators):
+            right = expr.operands[i + 1]
+            pieces.append(f"{right.type.cpp_type} {names[i+1]} = {self._expr(right)};")
+            cmp_expr = self._comparison_operand(expr.operands[i], right, op, names[i], names[i+1])
+            pieces.append(f"if (!({cmp_expr})) return false;")
+        pieces.append("return true;")
+        return "([&]() -> bool { " + " ".join(pieces) + " }())"
+
+    def _comparison_operand(self, left_expr: IRExpr, right_expr: IRExpr, op: IRCompareOp, left: str, right: str) -> str:
+        lt, rt = left_expr.type.kind, right_expr.type.kind
+        if lt == TypeKind.STRING and rt == TypeKind.STRING:
+            eq = f"_bj_str_eq({left}, {right})"
+            if op == IRCompareOp.EQ: return eq
+            if op == IRCompareOp.NE: return f"(!{eq})"
+            raise InternalCompilerError("Ordered string comparison reached backend after validation.")
+        if lt == TypeKind.TIME_U32 and rt == TypeKind.INT:
+            right = f"((uint32_t)({right}))" if self._known_nonnegative_int(right_expr) else f"_bj_time_threshold({right})"
+        elif rt == TypeKind.TIME_U32 and lt == TypeKind.INT:
+            left = f"((uint32_t)({left}))" if self._known_nonnegative_int(left_expr) else f"_bj_time_threshold({left})"
+        token = {IRCompareOp.EQ:"==", IRCompareOp.NE:"!=", IRCompareOp.LT:"<", IRCompareOp.LE:"<=", IRCompareOp.GT:">", IRCompareOp.GE:">="}[op]
+        return f"({left} {token} {right})"
+
+    def _call(self, call: IRCall) -> str:
+        args = [self._expr(a) for a in call.args]
+        if call.kind == IRCallKind.BUILTIN:
+            name = call.name
+            if name == "round":
+                arg = call.args[0]
+                if len(args) == 1:
+                    return args[0] if arg.type.kind == TypeKind.INT else f"_bj_round_i32((float)({args[0]}))"
+                ndigits = self._const_int(call.args[1])
+                if ndigits is None: raise InternalCompilerError("round() ndigits is not constant in typed IR.")
+                return f"_bj_round_i32_digits({args[0]}, {ndigits})" if arg.type.kind == TypeKind.INT else f"_bj_round_f32_digits((float)({args[0]}), {ndigits})"
+            if name in {"min", "max"}: return self._minmax_expr(call, want_min=name == "min")
+            if name == "int": return f"_bj_float_to_i32((float)({args[0]}))" if call.args[0].type.kind == TypeKind.FLOAT else f"((int32_t)({args[0]}))"
+            if name == "float": return f"((float)({args[0]}))"
+            if name == "bool": return f"((bool)({args[0]}))"
+            if name == "abs": return f"_bj_i32_abs({args[0]})" if call.args[0].type.kind == TypeKind.INT else f"fabsf((float)({args[0]}))"
+            if name == "len":
+                typ = call.args[0].type
+                if typ.kind != TypeKind.FIXED_LIST or typ.length is None: raise InternalCompilerError("len() reached backend without fixed-list IR type.")
+                return str(typ.length)
+            if name == "sum":
+                arg = call.args[0]
+                if not isinstance(arg, IRLoad) or arg.type.kind != TypeKind.FIXED_LIST or arg.type.length is None or arg.type.element_type is None:
+                    raise InternalCompilerError("sum() reached backend without fixed-list load.")
+                idx = self._new_temp("sum_i"); acc = self._new_temp("sum_acc")
+                if arg.type.element_type.kind == TypeKind.INT:
+                    return f"([&]() -> int32_t {{ int32_t {acc} = 0; for (int32_t {idx} = 0; {idx} < {arg.type.length}; ++{idx}) {acc} = _bj_i32_add({acc}, {arg.symbol.backend_name}[{idx}]); return {acc}; }}())"
+                return f"([&]() -> float {{ float {acc} = 0.0f; for (int32_t {idx} = 0; {idx} < {arg.type.length}; ++{idx}) {acc} += {arg.symbol.backend_name}[{idx}]; return {acc}; }}())"
+            raise InternalCompilerError(f"Unsupported builtin '{name}' reached Uno backend.")
+
+        if call.kind == IRCallKind.USER_FUNCTION:
+            if call.function_symbol is None: raise InternalCompilerError("User-function IR call is missing function symbol.")
+            callee = call.function_symbol.backend_name
+        elif call.kind == IRCallKind.API_FUNCTION:
+            callee = call.name
+            if call.name == "tone":
+                if not self._known_int_within(call.args[1], 31, 65535):
+                    args[1] = f"_bj_tone_frequency({args[1]})"; self._dynamic_helpers.add("_bj_tone_frequency")
+                if len(call.args) == 3 and self._needs_nonnegative_guard(call.args[2]):
+                    args[2] = f"_bj_time_threshold({args[2]})"; self._dynamic_helpers.add("_bj_time_threshold")
+            elif call.name == "delayMicroseconds":
+                if not self._known_int_within(call.args[0], 0, 16383):
+                    args[0] = f"_bj_delay_us({args[0]})"; self._dynamic_helpers.add("_bj_delay_us")
+            elif call.name == "map":
+                callee = "_bj_arduino_map"; self._dynamic_helpers.add("_bj_arduino_map")
+            elif call.name == "constrain":
+                callee = "_bj_constrain_int"; self._dynamic_helpers.add("_bj_constrain_int")
+            if call.name == "analogWrite" and len(call.args) >= 2 and id(call) not in self._safe_pwm_call_ids and not self._known_pwm_safe(call.args[1], self._active_int_ranges):
+                args[1] = f"_bj_pwm_value({args[1]})"; self._dynamic_helpers.add("_bj_pwm_value")
+            if call.name == "pinMode" and len(call.args) >= 2 and not self._known_int_within(call.args[1], 0, 2):
+                args[1] = f"_bj_pin_mode({args[1]})"; self._dynamic_helpers.add("_bj_pin_mode")
+            if call.name == "digitalWrite" and len(call.args) >= 2 and not self._known_int_within(call.args[1], 0, 1):
+                args[1] = f"_bj_digital_level({args[1]})"; self._dynamic_helpers.add("_bj_digital_level")
+            pin_guard = _PIN_GUARDS.get(call.name)
+            if pin_guard is not None and call.args and not self._pin_is_proven(call.args[0], _PIN_SETS[pin_guard]):
+                args[0] = f"{pin_guard}({args[0]})"; self._dynamic_helpers.add(pin_guard)
+            if call.name == "delay" and call.args and self._needs_nonnegative_guard(call.args[0]):
+                args[0] = f"_bj_time_threshold({args[0]})"; self._dynamic_helpers.add("_bj_time_threshold")
+        elif call.kind == IRCallKind.OBJECT_METHOD:
+            if call.owner_symbol is None or call.method_name is None: raise InternalCompilerError("Object-method IR call is incomplete.")
+            callee = f"{call.owner_symbol.backend_name}.{call.method_name}"
+            guard = self._object_arg_guard(call)
+            if guard is not None:
+                args[0] = f"{guard}({args[0]})"; self._dynamic_helpers.add(guard)
+            cls = call.owner_symbol.type.hardware_class
+            if cls == "Servo" and call.method_name == "writeMicroseconds" and call.args:
+                if not self._known_int_within(call.args[0], 0, 3000):
+                    args[0] = f"_bj_servo_pulse({args[0]})"; self._dynamic_helpers.add("_bj_servo_pulse")
+            if cls == "Servo" and call.method_name == "attach" and len(call.args) == 3:
+                return self._ordered_servo_attach(call, callee, args)
+            if cls == "LiquidCrystal_I2C" and call.method_name == "begin" and len(call.args) >= 2:
+                for index in (0, 1):
+                    if not self._known_int_within(call.args[index], 1, 255):
+                        args[index] = f"_bj_lcd_dimension({args[index]})"; self._dynamic_helpers.add("_bj_lcd_dimension")
+                if len(call.args) >= 3 and not self._known_int_in_set(call.args[2], {0, 4}):
+                    args[2] = f"_bj_lcd_charsize({args[2]})"; self._dynamic_helpers.add("_bj_lcd_charsize")
+            if cls == "LiquidCrystal_I2C" and call.method_name == "setCursor" and len(call.args) >= 2:
+                if not self._known_int_within(call.args[0], 0, 255):
+                    args[0] = f"_bj_lcd_cursor_column({args[0]})"; self._dynamic_helpers.add("_bj_lcd_cursor_column")
+                if not self._known_int_within(call.args[1], 0, 3):
+                    args[1] = f"_bj_lcd_cursor_row({args[1]})"; self._dynamic_helpers.add("_bj_lcd_cursor_row")
+        elif call.kind == IRCallKind.SINGLETON_METHOD:
+            if call.owner_name is None or call.method_name is None: raise InternalCompilerError("Singleton-method IR call is incomplete.")
+            callee = f"{call.owner_name}.{call.method_name}"
+            if call.owner_name == "Wire":
+                if call.method_name in {"beginTransmission", "requestFrom"} and call.args and not self._known_int_within(call.args[0], 0, 127):
+                    args[0] = f"_bj_i2c_address({args[0]})"; self._dynamic_helpers.add("_bj_i2c_address")
+                if call.method_name == "write" and call.args and not self._known_int_within(call.args[0], 0, 255):
+                    args[0] = f"_bj_byte_value({args[0]})"; self._dynamic_helpers.add("_bj_byte_value")
+                if call.method_name == "requestFrom" and len(call.args) >= 2 and not self._known_int_within(call.args[1], 0, 255):
+                    args[1] = f"_bj_wire_count({args[1]})"; self._dynamic_helpers.add("_bj_wire_count")
+                # Pinned AVR TwoWire overloads beginTransmission(uint8_t|int) and
+                # requestFrom(uint8_t,uint8_t|int,int): an int32_t argument (any Python
+                # variable) is ambiguous in C++.  The values are already proven or guarded
+                # to 0..127 / 0..255, so select the uint8_t overloads explicitly.
+                # The cast is applied at the call itself (also to ordered argument
+                # temporaries, which are declared int32_t).
+                if call.method_name == "beginTransmission" and call.args:
+                    return self._ordered_call(call, callee, args, casts={0: "uint8_t"})
+                if call.method_name == "requestFrom" and len(call.args) >= 2:
+                    return self._ordered_call(call, callee, args, casts={0: "uint8_t", 1: "uint8_t"})
+            if call.owner_name == "Serial" and call.method_name in {"print", "println"} and len(call.args) == 2:
+                if not self._known_int_within(call.args[1], 0, 255):
+                    args[1] = f"_bj_arduino_format({args[1]})"; self._dynamic_helpers.add("_bj_arduino_format")
+        else:
+            raise InternalCompilerError("Unknown IR call category reached Uno backend.")
+        return self._ordered_call(call, callee, args)
+
+    def _pin_is_proven(self, expr: IRExpr, allowed: frozenset[int]) -> bool:
+        """True only when the pin value is fixed at compile time (or range-proven) and valid.
+
+        Target analysis rejects provably wrong pins; everything it cannot fix at
+        compile time gets a runtime check so an invalid pin never reaches the core.
+        """
+        value = self._const_int(expr)
+        if value is not None:
+            return value in allowed
+        if isinstance(expr, IRLoad):
+            if expr.symbol.kind in {SymbolKind.API, SymbolKind.BUILTIN}:
+                from ..api_registry import CONSTANT_VALUES
+                return CONSTANT_VALUES.get(expr.symbol.source_name) in allowed
+            if expr.symbol.symbol_id in self._constant_symbol_values:
+                return self._constant_symbol_values[expr.symbol.symbol_id] in allowed
+            facts = self._active_int_ranges.get(expr.symbol.symbol_id)
+            if facts is not None:
+                return all(v in allowed for v in range(facts[0], facts[1] + 1))
+        return False
+
+    def _needs_nonnegative_guard(self, expr: IRExpr) -> bool:
+        value = self._const_int(expr)
+        if value is not None:
+            return value < 0
+        if isinstance(expr, IRLoad):
+            facts = self._active_int_ranges.get(expr.symbol.symbol_id)
+            if facts is not None and facts[0] >= 0:
+                return False
+        return True
+
+    def _object_arg_guard(self, call: IRCall) -> str | None:
+        """Runtime argument policy for hardware methods (registry constraints)."""
+        if not call.args or call.owner_symbol is None:
+            return None
+        cls = call.owner_symbol.type.hardware_class
+        if cls == "Servo" and call.method_name == "write":
+            value = self._const_int(call.args[0])
+            if value is not None and 0 <= value <= 180:
+                return None
+            if isinstance(call.args[0], IRLoad):
+                facts = self._active_int_ranges.get(call.args[0].symbol.symbol_id)
+                if facts is not None and facts[0] >= 0 and facts[1] <= 180:
+                    return None
+            return "_bj_servo_angle"
+        if cls == "Ultrasonic" and call.method_name == "setTimeout":
+            return "_bj_time_threshold" if self._needs_nonnegative_guard(call.args[0]) else None
+        return None
+
+    def _ordered_servo_attach(self, call: IRCall, callee: str, args: list[str]) -> str:
+        # Servo 1.3.0 stores min/max calibration offsets in int8_t.  Materialize
+        # all Python arguments in order, validate the pair once, then call the library.
+        self._dynamic_helpers.add("_bj_servo_attach_bounds")
+        decls: list[str] = []; names: list[str] = []
+        for arg, text in zip(call.args, args):
+            name = self._new_temp("servo_attach_arg"); names.append(name)
+            decls.append(f"{arg.type.cpp_type} {name} = {text};")
+        decls.append(f"_bj_servo_attach_bounds({names[1]}, {names[2]});")
+        invocation = f"{callee}({', '.join(names)})"
+        if call.type.kind == TypeKind.VOID:
+            return "([&]() { " + " ".join(decls) + f" {invocation}; }}())"
+        return f"([&]() -> {call.type.cpp_type} {{ " + " ".join(decls) + f" return {invocation}; }}())"
+
+    def _ordered_call(self, call: IRCall, callee: str, args: list[str], *, casts: dict[int, str] | None = None) -> str:
+        casts = casts or {}
+        def cast(index: int, text: str) -> str:
+            return f"({casts[index]})({text})" if index in casts else text
+        if len(call.args) <= 1 or not any(self._expr_has_effects(a) for a in call.args):
+            return f"{callee}({', '.join(cast(i, a) for i, a in enumerate(args))})"
+        decls: list[str] = []; names: list[str] = []
+        for arg, text in zip(call.args, args):
+            name = self._new_temp("arg"); names.append(name); decls.append(f"{arg.type.cpp_type} {name} = {text};")
+        invocation = f"{callee}({', '.join(cast(i, n) for i, n in enumerate(names))})"
+        if call.type.kind == TypeKind.VOID: return "([&]() { " + " ".join(decls) + f" {invocation}; }}())"
+        return f"([&]() -> {call.type.cpp_type} {{ " + " ".join(decls) + f" return {invocation}; }}())"
+
+    def _minmax_expr(self, call: IRCall, *, want_min: bool) -> str:
+        names: list[str] = []; parts: list[str] = []
+        for arg in call.args:
+            name = self._new_temp("minmax_arg"); names.append(name); parts.append(f"{arg.type.cpp_type} {name} = {self._expr(arg)};")
+        result = self._new_temp("minmax"); parts.append(f"{call.type.cpp_type} {result} = {names[0]};")
+        token = "<" if want_min else ">"
+        for name in names[1:]: parts.append(f"if ({name} {token} {result}) {result} = {name};")
+        parts.append(f"return {result};")
+        return f"([&]() -> {call.type.cpp_type} {{ " + " ".join(parts) + " }())"
+
+    def _python_print(self, stmt: IRPrint, indent: int) -> list[str]:
+        pad = "    " * indent; preludes: list[str] = []; parts: list[_OutputPart] = []
+        for i, arg in enumerate(stmt.values):
+            if i: parts.append(_OutputPart(literal=" "))
+            pre, argparts = self._prepare_output_arg(arg); preludes.extend(pre); parts.extend(argparts)
+        out = [pad + x for x in preludes]
+        for part in parts: out.extend(self._emit_output_part("Serial", part, indent, lcd_mode=False))
+        if stmt.newline: out.append(pad + "Serial.println();")
+        return out
+
+    def _explicit_output_stmt(self, expr: IRExpr, indent: int) -> list[str] | None:
+        if not isinstance(expr, IRCall) or expr.kind not in {IRCallKind.OBJECT_METHOD, IRCallKind.SINGLETON_METHOD}: return None
+        if expr.method_name not in {"print", "println"} or len(expr.args) != 1: return None
+        owner = expr.owner_symbol.backend_name if expr.owner_symbol is not None else expr.owner_name
+        if owner is None: return None
+        lcd_mode = expr.owner_symbol is not None and expr.owner_symbol.type.hardware_class == "LiquidCrystal_I2C"
+        arg = expr.args[0]; pad = "    " * indent
+        if isinstance(arg, IRConstant) and isinstance(arg.value, str): return [f"{pad}{owner}.{expr.method_name}({self._flash_literal(arg.value, lcd_mode=lcd_mode)});"]
+        if isinstance(arg, IRFormatString):
+            preludes, parts = self._prepare_output_arg(arg); out = [pad + x for x in preludes]
+            for part in parts: out.extend(self._emit_output_part(owner, part, indent, lcd_mode=lcd_mode))
+            if expr.method_name == "println": out.append(f"{pad}{owner}.println();")
+            return out
+        return None
+
+    def _prepare_output_arg(self, expr: IRExpr) -> tuple[list[str], list[_OutputPart]]:
+        if isinstance(expr, IRFormatString):
+            preludes: list[str] = []; parts: list[_OutputPart] = []
+            for part in expr.parts:
+                if isinstance(part, str):
+                    if part: parts.append(_OutputPart(literal=part))
+                else:
+                    pre, out = self._prepare_output_value(part.value, part.precision); preludes.extend(pre); parts.append(out)
+            return preludes, parts
+        if isinstance(expr, IRConstant) and isinstance(expr.value, str): return [], [_OutputPart(literal=expr.value)]
+        pre, part = self._prepare_output_value(expr, None); return pre, [part]
+
+    def _prepare_output_value(self, expr: IRExpr, precision: int | None) -> tuple[list[str], _OutputPart]:
+        if expr.type.kind not in {TypeKind.BOOL, TypeKind.INT, TypeKind.TIME_U32, TypeKind.FLOAT, TypeKind.STRING}: raise InternalCompilerError(f"Non-printable IR type {expr.type.kind.value} reached output backend.")
+        text = self._expr(expr)
+        if isinstance(expr, IRConstant): return [], _OutputPart(expression=text, type_kind=expr.type.kind, precision=precision)
+        temp = self._new_temp("print_arg")
+        return [f"{expr.type.cpp_type} {temp} = {text};"], _OutputPart(expression=temp, type_kind=expr.type.kind, precision=precision)
+
+    def _emit_output_part(self, sink: str, part: _OutputPart, indent: int, *, lcd_mode: bool) -> list[str]:
+        pad = "    " * indent
+        if part.literal is not None: return [f"{pad}{sink}.print({self._flash_literal(part.literal, lcd_mode=lcd_mode)});"]
+        if part.expression is None or part.type_kind is None: raise InternalCompilerError("Malformed output part reached Uno backend.")
+        e = part.expression
+        if part.precision is not None: return [f"{pad}_bj_print_py_fixed({sink}, (float)({e}), {part.precision});"]
+        if part.type_kind == TypeKind.BOOL: return [f"{pad}if ({e}) {sink}.print(F(\"True\")); else {sink}.print(F(\"False\"));"]
+        if part.type_kind == TypeKind.INT: return [f"{pad}{sink}.print((int32_t)({e}));"]
+        if part.type_kind == TypeKind.TIME_U32: return [f"{pad}{sink}.print((uint32_t)({e}));"]
+        if part.type_kind == TypeKind.FLOAT: return [f"{pad}_bj_print_py_float({sink}, (float)({e}));"]
+        if part.type_kind == TypeKind.STRING: return [f"{pad}{sink}.print({e});"]
+        raise InternalCompilerError("Unsupported output type reached Uno backend.")
+
+    def _required_numeric_helpers(self) -> set[str]:
+        need: set[str] = set()
+        for item in _walk(self.ir):
+            if isinstance(item, IRIndex) and self._const_int(item.index) is None: need.add("_bj_list_index")
+            elif isinstance(item, IRIndexStore) and self._const_int(item.index) is None: need.add("_bj_list_index")
+            elif isinstance(item, IRRangeLoop):
+                # The range iterator no longer uses checked addition (see _stmt); only a
+                # dynamic step needs the zero-step trap.
+                if self._const_int(item.step) is None: need.add("_bj_numeric_fail")
+            elif isinstance(item, IRFixedListLoop) and item.index_start is not None: need.add("_bj_i32_add")
+            elif isinstance(item, IRBinary):
+                if item.op == IRBinaryOp.TRUE_DIVIDE: need.add("_bj_true_div_f32")
+                elif item.op == IRBinaryOp.MODULO: need.add("_bj_mod_f32" if item.type.kind == TypeKind.FLOAT else "_bj_mod_i32")
+                elif item.checked and item.type.kind == TypeKind.INT:
+                    name = {IRBinaryOp.ADD:"_bj_i32_add", IRBinaryOp.SUBTRACT:"_bj_i32_sub", IRBinaryOp.MULTIPLY:"_bj_i32_mul"}.get(item.op)
+                    if name: need.add(name)
+            elif isinstance(item, IRAugStore):
+                if item.op == IRBinaryOp.TRUE_DIVIDE: need.add("_bj_true_div_f32")
+                elif item.op == IRBinaryOp.MODULO: need.add("_bj_mod_f32" if item.target.type.kind == TypeKind.FLOAT else "_bj_mod_i32")
+                elif item.target.type.kind == TypeKind.INT:
+                    name = {IRBinaryOp.ADD:"_bj_i32_add", IRBinaryOp.SUBTRACT:"_bj_i32_sub", IRBinaryOp.MULTIPLY:"_bj_i32_mul"}.get(item.op)
+                    if name: need.add(name)
+            elif isinstance(item, IRUnary) and item.type.kind == TypeKind.INT and IREffect.MAY_FAIL in item.effects: need.add("_bj_i32_neg")
+            elif isinstance(item, IRCompareChain):
+                for a, b in zip(item.operands, item.operands[1:]):
+                    if a.type.kind == b.type.kind == TypeKind.STRING: need.add("_bj_str_eq")
+                    if (a.type.kind == TypeKind.TIME_U32 and b.type.kind == TypeKind.INT and not self._known_nonnegative_int(b)) or (b.type.kind == TypeKind.TIME_U32 and a.type.kind == TypeKind.INT and not self._known_nonnegative_int(a)): need.add("_bj_time_threshold")
+            elif isinstance(item, IRCall):
+                if item.kind == IRCallKind.API_FUNCTION and item.name == "analogWrite" and len(item.args) >= 2 and id(item) not in self._safe_pwm_call_ids and not self._known_pwm_safe(item.args[1]): need.add("_bj_pwm_value")
+                if item.kind == IRCallKind.BUILTIN:
+                    if item.name == "int" and item.args and item.args[0].type.kind == TypeKind.FLOAT: need.add("_bj_float_to_i32")
+                    elif item.name == "round" and item.args:
+                        if len(item.args) == 1 and item.args[0].type.kind == TypeKind.FLOAT: need.add("_bj_round_i32")
+                        elif len(item.args) == 2 and item.args[0].type.kind == TypeKind.FLOAT: need.add("_bj_round_f32_digits")
+                        elif len(item.args) == 2 and item.args[0].type.kind == TypeKind.INT: need.add("_bj_round_i32_digits")
+                    elif item.name == "abs" and item.args and item.args[0].type.kind == TypeKind.INT: need.add("_bj_i32_abs")
+                    elif item.name == "sum" and item.args and item.args[0].type.kind == TypeKind.FIXED_LIST and item.args[0].type.element_type is not None and item.args[0].type.element_type.kind == TypeKind.INT: need.add("_bj_i32_add")
+        return _helper_closure(need)
+
+    @staticmethod
+    def _helper_order(names: set[str]) -> list[str]:
+        order = [_helper_name(line) for line in _NUMERIC_HELPER_BLOB.splitlines() if line.startswith("static ")]
+        return [name for name in order if name in names]
+
+    def _needs_python_float_formatter(self) -> bool:
+        for item in _walk(self.ir):
+            if isinstance(item, IRPrint):
+                if any(self._output_arg_needs_float_formatter(arg) for arg in item.values): return True
+            elif isinstance(item, IRExprStmt) and isinstance(item.expression, IRCall):
+                call = item.expression
+                if call.method_name in {"print", "println"} and len(call.args) == 1 and isinstance(call.args[0], IRFormatString) and self._output_arg_needs_float_formatter(call.args[0]): return True
+        return False
+
+    def _needs_fixed_float_formatter(self) -> bool:
+        return any(isinstance(item, IRFormattedValue) and item.precision is not None for item in _walk(self.ir))
+
+    @staticmethod
+    def _output_arg_needs_float_formatter(expr: IRExpr) -> bool:
+        if isinstance(expr, IRFormatString): return any(isinstance(p, IRFormattedValue) and p.precision is None and p.value.type.kind == TypeKind.FLOAT for p in expr.parts)
+        return expr.type.kind == TypeKind.FLOAT
+
+    @staticmethod
+    def _expr_has_effects(expr: IRExpr) -> bool: return bool(expr.effects)
+
+    @staticmethod
+    def _const_int(expr: IRExpr) -> int | None:
+        if isinstance(expr, IRConstant) and isinstance(expr.value, int) and not isinstance(expr.value, bool): return expr.value
+        if isinstance(expr, IRUnary) and expr.op == IRUnaryOp.NEGATE and expr.type.kind == TypeKind.INT:
+            # Nested literal negation (e.g. round(x, --2)) is folded exactly like the
+            # type/numeric phases fold it, so accepted programs never reach an ICE.
+            inner = UnoCppBackend._const_int(expr.operand)
+            return -inner if inner is not None else None
+        return None
+
+    def _known_nonnegative_int(self, expr: IRExpr) -> bool:
+        value = self._const_int(expr); return value is not None and value >= 0
+
+    def _known_int_within(self, expr: IRExpr, low: int, high: int) -> bool:
+        value = self._const_int(expr)
+        if value is not None:
+            return low <= value <= high
+        if isinstance(expr, IRLoad):
+            if expr.symbol.kind in {SymbolKind.API, SymbolKind.BUILTIN}:
+                from ..api_registry import CONSTANT_VALUES
+                value = CONSTANT_VALUES.get(expr.symbol.source_name)
+                return value is not None and low <= value <= high
+            if expr.symbol.symbol_id in self._constant_symbol_values:
+                value = self._constant_symbol_values[expr.symbol.symbol_id]
+                return low <= value <= high
+            facts = self._active_int_ranges.get(expr.symbol.symbol_id)
+            return facts is not None and low <= facts[0] and facts[1] <= high
+        return False
+
+    def _known_int_in_set(self, expr: IRExpr, allowed: set[int]) -> bool:
+        value = self._const_int(expr)
+        if value is not None:
+            return value in allowed
+        if isinstance(expr, IRLoad):
+            if expr.symbol.kind in {SymbolKind.API, SymbolKind.BUILTIN}:
+                from ..api_registry import CONSTANT_VALUES
+                value = CONSTANT_VALUES.get(expr.symbol.source_name)
+                return value in allowed if value is not None else False
+            if expr.symbol.symbol_id in self._constant_symbol_values:
+                return self._constant_symbol_values[expr.symbol.symbol_id] in allowed
+            facts = self._active_int_ranges.get(expr.symbol.symbol_id)
+            if facts is not None and facts[1] - facts[0] <= 16:
+                return all(v in allowed for v in range(facts[0], facts[1] + 1))
+        return False
+
+    def _known_pwm_safe(self, expr: IRExpr, ranges: dict[object, tuple[int, int]] | None = None) -> bool:
+        value = self._const_int(expr)
+        if value is not None:
+            return 0 <= value <= 255
+        if isinstance(expr, IRLoad):
+            facts = (ranges or {}).get(expr.symbol.symbol_id)
+            return facts is not None and 0 <= facts[0] and facts[1] <= 255
+        return False
+
+    def _list_index_expr(self, index: IRExpr, list_type) -> str:
+        if list_type.kind != TypeKind.FIXED_LIST or list_type.length is None: raise InternalCompilerError("List indexing reached backend without fixed-list type.")
+        literal = self._const_int(index)
+        return str(literal) if literal is not None else f"_bj_list_index({self._expr(index)}, {list_type.length})"
+
+    def _new_temp(self, hint: str) -> str:
+        self._temp_counter += 1; return f"_bj_tmp_{hint}_{self._temp_counter:04d}"
+
+    def _temp_name(self, temp: IRTempRef, hint: str) -> str:
+        name = self._temp_names.get(temp.temp_id)
+        if name is None:
+            name = self._new_temp(hint); self._temp_names[temp.temp_id] = name
+        return name
+
+    @staticmethod
+    def _flash_literal(text: str, *, lcd_mode: bool = False) -> str: return f"F({UnoCppBackend._cpp_string_literal(text, lcd_mode=lcd_mode)})"
+
+    @staticmethod
+    def _cpp_string_literal(text: str, *, lcd_mode: bool = False) -> str:
+        data = bytearray()
+        if lcd_mode:
+            for ch in text:
+                code = ord(ch)
+                if 0x20 <= code <= 0x7E: data.append(code)
+                elif ch == "°": data.append(0xDF)
+                else: raise InternalCompilerError("Unsupported LCD character reached backend after target validation.")
+        else: data.extend(text.encode("utf-8"))
+        pieces: list[str] = []
+        for byte in data:
+            if byte == 0x5C: pieces.append("\\\\")
+            elif byte == 0x22: pieces.append('\\"')
+            elif byte == 0x0A: pieces.append("\\n")
+            elif byte == 0x0D: pieces.append("\\r")
+            elif byte == 0x09: pieces.append("\\t")
+            elif 0x20 <= byte <= 0x7E: pieces.append(chr(byte))
+            else: pieces.append(f"\\{byte:03o}")
+        return '"' + "".join(pieces) + '"'
+
+
+def generate_uno_cpp(ir_module: IRModule, target_plan: TargetPlan) -> GeneratedSketch:
+    return UnoCppBackend(ir_module, target_plan).generate()