/// The latter is necessary because recursive SSA resolution may have already

/// patched terminator arguments with the provisional value before it was

/// found to be trivial.

unsafe fn rewriteCachedVarValue 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, v: Var, from: il::Val, to: il::Val) where 'arena: 'phase, 'phase: 'function {

    for i in 0..self.blockData.len {

        if blk.vars[*v] == from {

            set blk.vars[*v] = to;

        }

        if blk.instrs.len > 0 {

            let ix = blk.instrs.len - 1;

/// Get the number of predecessors for a block.

fn predecessorCount(blocks: &[BlockData], block: BlockId) -> u32 {

    return blocks[*block].preds.len;

}

/// Get the current block being built.

fn currentBlock 'arena 'phase 'function (self: &FnLowerer 'arena 'phase 'function) -> BlockId where 'arena: 'phase, 'phase: 'function {

    let block = self.currentBlock else {

        panic "currentBlock: no current block";

    };

    from: BlockId,         // The predecessor block containing the terminator to patch.

    target: u32,           // The index of the target block we're passing the value to.

    paramIdx: u32,         // The index of the block parameter to set.

    val: il::Val           // The value to pass as the argument.

) where 'arena: 'phase, 'phase: 'function {

    let ix = data.instrs.len - 1; // The terminator is always the last instruction.

    // TODO: We shouldn't need to use a mutable subscript here, given that the

    // fields are already mutable.

    match &mut data.instrs[ix] {

        case il::Instr::Jmp { args, .. } => {

            set args[paramIdx] = val;

        }

        case il::Instr::Br { thenTarget, thenArgs, elseTarget, elseArgs, .. } => {

            // Nb. both branches could target the same block (e.g. `if cond { x } else { x }`).

            if *thenTarget == target {

                set thenArgs[paramIdx] = val;

            }

            if *elseTarget == target {

                set elseArgs[paramIdx] = val;

            }

        }

        case il::Instr::Switch { defaultTarget, defaultArgs, cases, .. } => {

            if *defaultTarget == target {

                set defaultArgs[paramIdx] = val;

            }

            let idx = paramIdx + 1;

            for ci in 0..cases.len {

                if cases[ci].target == target {

                    set cases[ci].args[paramIdx] = val;

                }

            }

        }

        else => {

        }

    }

}

/// Grow an args array to hold at least the given capacity.

    if args.len >= capacity {

        return args;

    }

    let mut newArgs: *mut [il::Val] = &mut [];

    for arg in args {

    }

    for i in args.len..capacity {

    }

    return (&mut newArgs[..]) as *unsafe mut [il::Val];

}

/// Select a receiver or explicit parameter name from its AST declaration.

    let mut d: u32 = 4;

    let mut e: u32 = 5;

    let mut f: u32 = 6;

    let mut g: u32 = 7;

    let mut h: u32 = 8;

    for index in 0..limit {

        let mut step: u32 = 0;

        match index % 3 {

        }

        if index % 2 == 0 {

            set a += step;

            set c += step * 3;

            set e += step * 5;

            set b += step * 2;

            set d += step * 4;

            set f += step * 6;

            set h += step * 8;

        }

    }

    return a + 2*b + 3*c + 4*d + 5*e + 6*f + 7*g + 8*h;

}

/// Compute the weighted sum without carrying the eight separate values.

fn expected(limit: u32) -> u32 {