);

    frame.totalSize = totalSize;

    // Build list of callee-saved registers with offsets.

    let mut offset = totalSize - (super::DWORD_SIZE * 3);

        // Check if this register is in use.

        if (usedCalleeSaved & (1 << i)) != 0 {

            frame.savedRegs[frame.savedRegsLen] = SavedReg {

                offset,

            };

            frame.savedRegsLen += 1;

            offset -= super::DWORD_SIZE;

        }

    // Move function params from arg registers to assigned registers.

    // Cross-call params may have been assigned to callee-saved registers

    // instead of their natural arg registers. Spilled params are stored

    // directly to their spill slots.

        if i < super::ARG_REGS.len {

            let argReg = super::ARG_REGS[i];

            if let slot = regalloc::spill::spillSlot(&ralloc.spill, param) {

                // Spilled parameter: store arg register to spill slot.

                emit::emitSd(s.e, argReg, super::FP, spillOffset(&s, slot));

    // By the time we enter the block, the arguments have already been

    // moved to the parameter registers by the predecessor's terminator.

    // Process each instruction, auto-committing any pending spill after each.

    let hasLocs = block.locs.len > 0;

        // Record debug location before emitting machine instructions.

        if hasLocs {

            emit::recordSrcLoc(s.e, block.locs[i]);

        }

        s.pendingSpill = nil;

        // Flush the pending spill store, if any.

        if let p = s.pendingSpill {

            if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, p.ssa) {

                emit::emitSd(s.e, p.rd, super::FP, spillOffset(s, slot));

    // Destination registers for each arg.

    // Zero means the destination is spilled or skipped.

    let mut dsts: [super::Reg; MAX_BLOCK_ARGS] = [super::ZERO; MAX_BLOCK_ARGS];

        let param = block.params[i].value;

        // Spilled destinations: store directly to spill slot.

        // These don't participate in the parallel move algorithm.

        if let slot = regalloc::spill::spillSlot(&s.ralloc.spill, param) {

                // Undefined values don't need any move.

            } else {

                emit::emitSd(s.e, rs, super::FP, spillOffset(s, slot));

            }

        } else {

            dsts[i] = getReg(s, param);

        }

    write(out, ")");

}

/// Write strings separated by ", ".

fn writeDelim(out: *mut sexpr::Output, parts: *[*[u8]]) {

        if i > 0 {

            write(out, ", ");

        }

    }

}

/// Write mnemonic with padding for alignment.

fn writeMnem(out: *mut sexpr::Output, m: *[u8]) {

    // Package header.

    write(out, "# package `");

    write(out, pkgName);

    write(out, "`\n\n");

        if let name = findFunc(funcs, i) {

            write(out, "\n# ");

            write(out, name);

            write(out, "\n\n");

        }

        write(out, "\n");

    }

}

/// Find function at given instruction index.

fn nodeListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

    }

    return buf;

}

/// Convert an optional node to an expression, or return placeholder.

fn prongListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

        match prong.value {

            case super::NodeValue::MatchProng(p) => {

                buf[i] = prongToExpr(a, p);

            }

            else => {

fn fieldListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

        match node.value {

            case super::NodeValue::RecordField { field, type, value } => {

                buf[i] = fieldToExpr(a, field, type, value);

            }

            else => {

fn variantListToExprs(a: *mut alloc::Arena, nodes: *[*super::Node]) -> *[sexpr::Expr] {

    if nodes.len == 0 {

        return &[];

    }

    let buf = try! sexpr::allocExprs(a, nodes.len as u32);

        match node.value {

            case super::NodeValue::UnionDeclVariant(v) => {

                buf[i] = variantToExpr(a, v.name, v.type);

            }

            else => {

        case super::NodeValue::UnOp(u) =>

            return sexpr::list(a, unOpName(u.op), &[toExpr(a, u.value)]),

        case super::NodeValue::Call(c) => {

            let buf = try! sexpr::allocExprs(a, c.args.len as u32 + 1);

            buf[0] = toExpr(a, c.callee);

            return sexpr::Expr::List { head: "call", tail: buf, multiline: false };

        }

        case super::NodeValue::BuiltinCall { kind, args } =>

            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),

        case super::NodeValue::Subscript { container, index } =>

            let buf = try! sexpr::allocExprs(a, total);

            let mut idx: u32 = 0;

            if let tn = lit.typeName {

                buf[idx] = toExpr(a, tn); idx = idx + 1;

            }

            }

            return sexpr::Expr::List { head: "record-lit", tail: buf, multiline: lit.fields.len > 2 };

        }

        case super::NodeValue::RecordLitField(f) =>

            return sexpr::list(a, "field", &[toExprOpt(a, f.label), toExpr(a, f.value)]),

/// Dump the tree rooted at `root`, using the provided arena for allocation.

pub fn printTree(root: *super::Node, arena: *mut alloc::Arena) {

    match root.value {

        case super::NodeValue::Block(blk) => {

                if i < blk.statements.len - 1 { io::print("\n\n"); }

            }

            io::print("\n");

        }

        else => {

    }

    // Pre-assign function parameters to argument registers.

    // Cross-call params are NOT pre-assigned here; they will be allocated

    // to callee-saved registers by the normal path, and isel emits moves

    // from the arg register to the assigned register at function entry.

        if i < config.argRegs.len {

            }

        }

    }

    let blkEnd = try alloc::allocSlice(arena, @sizeOf(RegMap), @alignOf(RegMap), blockCount) as *mut [RegMap];

    for i in 0..blockCount {

                assignments[p.value.n] = rallocReg(&mut current, &mut usedRegs, p.value.n, allocatable, config.calleeSaved, spillInfo);

            }

        }

        // Process each instruction.

            let mut ctx = InstrCtx {

                current: &mut current,

                usedRegs: &mut usedRegs,

                func,

                live,

    }

    // Compute bitmask of used callee-saved registers.

    let mut usedCalleeSaved: u32 = 0;

    for i in 0..maxReg {

        if let phys = assignments[i] {

                    usedCalleeSaved |= (1 << j);

                }

            }

        }

    }

}

/// Write a comma-separated argument list in parentheses.

fn writeArgs(out: *mut sexpr::Output, a: *mut alloc::Arena, args: *[super::Val]) {

    write(out, "(");

        if i > 0 {

            write(out, ", ");

        }

    }

    write(out, ")");

}

/// Write a typed parameter (e.g., `w32 %0`).

    writeReg(out, a, param.value);

}

/// Write a comma-separated parameter list.

fn writeParams(out: *mut sexpr::Output, a: *mut alloc::Arena, params: *[super::Param]) {

        if i > 0 {

            write(out, ", ");

        }

    }

}

//////////////////////////

// Instruction printing //

//////////////////////

/// Print a program.

pub fn printProgram(out: *mut sexpr::Output, a: *mut alloc::Arena, program: *super::Program) {

    // Data declarations.

        if i < program.data.len - 1 or program.fns.len > 0 {

            write(out, "\n");

        }

    }

    // Functions.

        if i < program.fns.len - 1 {

            write(out, "\n");

        }

    }

}

    }

    // Fill inherited method slots from supertraits.

    // These methods were already lowered as part of the supertrait instance

    // declarations and use the same `Type::method` qualified name.

        if not methodNameSet[i] {

        }

    }

    // Create v-table in data section, used for dynamic dispatch.

    let vName = vtableName(self, nil, typeName, tName);

    recInfo: resolver::RecordType,

    dataPrefix: *[u8],

    b: *mut DataValueBuilder

) throws (LowerError) {

    let layout = recInfo.layout;

        let mut valueNode = argNode;

        if let case ast::NodeValue::RecordLitField(fieldLit) = argNode.value {

            valueNode = fieldLit.value;

        }

        let fieldInfo = recInfo.fields[i];

    }

    let newArgs = try! alloc::allocSlice(

        self.low.arena, @sizeOf(il::Val), @alignOf(il::Val), capacity

    ) as *mut [il::Val];

    }

    for i in args.len..capacity {

        newArgs[i] = il::Val::Undef;

    }

    return newArgs;

    let mut blocks: [BlockId; 32] = undefined;

    let mut cases: *mut [il::SwitchCase] = &mut [];

    let mut defaultIdx: u32 = 0;

    let entry = currentBlock(self);

        let case ast::NodeValue::MatchProng(prong) = p.value

            else throw LowerError::UnexpectedNodeValue(p);

        match prong.arm {

            case ast::ProngArm::Binding(_), ast::ProngArm::Else => {

        defaultTarget: blocks[defaultIdx].n,

        defaultArgs: &mut [],

        cases: &mut cases[..]

    });

        let case ast::NodeValue::MatchProng(prong) = p.value

            else throw LowerError::UnexpectedNodeValue(p);

        try switchToAndSeal(self, blocks[i]);

        try lowerNode(self, prong.body);

    // Fallback: chained branches.

    let firstArm = try createBlock(self, "arm");

    try emitJmp(self, firstArm);

    try switchToAndSeal(self, firstArm);

        let prongScope = enterVarScope(self);

        let case ast::NodeValue::MatchProng(prong) = prongNode.value

            else panic "lowerMatch: expected match prong";

        let isLastArm = i + 1 == prongs.len;

        let hasGuard = prong.guard != nil;

    let cases = try! alloc::allocSlice(

        self.low.arena, @sizeOf(il::SwitchCase), @alignOf(il::SwitchCase), unionInfo.variants.len as u32

    ) as *mut [il::SwitchCase];

    let mut caseBlocks: [?BlockId; resolver::MAX_UNION_VARIANTS] = undefined;

            cases[i] = il::SwitchCase {

                value: i as i64,

                target: mergeBlock.n,

                args: trueArgs

            };

        }

    }

    let valOffset = unionInfo.valOffset as i32;

    // Emit payload comparison blocks for non-void variants.

        if let caseBlock = caseBlocks[i] {

            try switchToAndSeal(self, caseBlock);

            let payloadEq = try emitEqAtOffset(

            );

            try emitJmpWithArg(self, mergeBlock, payloadEq);

        }

    }

    // Emit unreachable block.

    dst: il::Reg,

    recInfo: *resolver::RecordType,

    fields: *mut [*ast::Node],

    offset: i32

) throws (LowerError) {

        let case ast::NodeValue::RecordLitField(field) = fieldNode.value else {

            throw LowerError::UnexpectedNodeValue(fieldNode);

        };

        let mut fieldIdx: u32 = i;

        if recInfo.labeled {

        throw LowerError::ExpectedRecord;

    };

    let typ = resolver::Type::Nominal(nominal);

    let dst = try emitReserve(self, typ);

        // Skip `undefined` arguments.

        if not isUndef(argNode) {

            let fieldTy = recInfo.fields[i].fieldType;

            let argVal = try lowerExpr(self, argNode);

            try emitStore(self, dst, recInfo.fields[i].offset, fieldTy, argVal);

    };

    let elemTy = *arrInfo.item;

    let elemLayout = resolver::getTypeLayout(elemTy);

    let dst = try emitReserve(self, typ);

        let elemVal = try lowerExpr(self, elemNode);

        let offset = i * elemLayout.size;

        try emitStore(self, dst, offset as i32, elemTy, elemVal);

    }

        dst: arrayReg,

        size: il::Val::Imm(arraySize as i64),

        alignment: elemLayout.alignment

    });

    // Store each element.

        let elemVal = try lowerExpr(self, elemNode);

        let offset = i * elemLayout.size;

        try emitStore(self, arrayReg, offset as i32, *elemTy, elemVal);

    }

    let mut blocks: [BlockId; MAX_CATCH_CLAUSES] = undefined;

    let mut errTypes: [?resolver::Type; MAX_CATCH_CLAUSES] = undefined;

    let mut cases: *mut [il::SwitchCase] = &mut [];

    let mut defaultIdx: ?u32 = nil;

        let case ast::NodeValue::CatchClause(clause) = clauseNode.value

            else panic "lowerMultiCatch: expected CatchClause";

        blocks[i] = try createBlock(self, "catch");

        addPredecessor(self, blocks[i], entry);

        defaultArgs: &mut [],

        cases

    });

    // Second pass: emit each catch clause body.

        let case ast::NodeValue::CatchClause(clause) = clauseNode.value

            else panic "lowerMultiCatch: expected CatchClause";

        try switchToAndSeal(self, blocks[i]);

        let savedVarsLen = enterVarScope(self);

    // Data pointer is the receiver (first argument after hidden return param).

    args[argOffset] = il::Val::Reg(dataReg);

    // Lower user arguments.

    }

    // Allocate the return buffer when needed.

    if returnParam {

        if methodFnType.throwList.len > 0 {

    // Lower function value and arguments, reserving an extra slot for the

    // hidden return buffer when needed.

    let callee = try lowerCallee(self, call.callee);

    let offset: u32 = 1 if returnParam else 0;

    let args = try allocVals(self, call.args.len + offset);

    }

    // Allocate the return buffer when needed.

    if returnParam {

        if fnInfo.throwList.len > 0 {

pub fn trimExtension(path: *[u8]) -> ?*[u8] {

    if path.len < SOURCE_EXT.len {

        return nil;

    }

    let extStart = path.len - SOURCE_EXT.len;

            return nil;

        }

    }

    return &path[..extStart];

}

    let idText = formatId(a, entry.id as u32);

    let path = super::moduleQualifiedPath(entry);

    let mut pathBuf: *[sexpr::Expr] = &[];

    if path.len > 0 {

        let buf = try! sexpr::allocExprs(a, path.len);

        pathBuf = buf;

    }

    let mut childBuf: *[sexpr::Expr] = &[];

    if entry.childrenLen > 0 {

/// assignable to its corresponding field type.

fn checkRecordConstructorArgs(self: *mut Resolver, node: *ast::Node, args: *mut [*ast::Node], recInfo: RecordType)

    throws (ResolveError)

{

    try checkRecordArity(self, args, recInfo, node);

        let fieldType = recInfo.fields[i].fieldType;

        try checkAssignable(self, arg, fieldType);

    }

}

            throw emitError(self, methodNode, ErrorKind::FnArgCountMismatch(CountMismatch {

                expected: tm.fnType.paramTypes.len as u32,

                actual: sig.params.len,

            }));

        }

            let case ast::NodeValue::FnParam(param) = paramNode.value

                else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);

            let instanceParamTy = try resolveValueType(self, param.type);

            if not typesEqual(instanceParamTy, *tm.fnType.paramTypes[j]) {

                throw emitTypeMismatch(self, paramNode, TypeMismatch {

            throw emitError(self, methodNode, ErrorKind::FnThrowCountMismatch(CountMismatch {

                expected: tm.fnType.throwList.len as u32,

                actual: sig.throwList.len,

            }));

        }

            if not typesEqual(instanceThrowTy, *tm.fnType.throwList[j]) {

                    expected: *tm.fnType.throwList[j],

                    actual: instanceThrowTy,

                });

            }

        }

    // Fill inherited method slots from supertrait instances.

    for superTrait in traitInfo.supertraits {

        let superInst = findInstance(self, superTrait, concreteType)

            else throw emitError(self, node, ErrorKind::MissingSupertraitInstance(superTrait.name));

                else panic "resolveInstanceDecl: inherited method not found";

            if not covered[merged.index] {

                entry.methods[merged.index] = superInst.methods[mi];

                covered[merged.index] = true;

            }

        }

    }

    // Check that all trait methods are implemented.

        if not covered[i] {

        }

    }

    self.instances[self.instancesLen] = entry;

    self.instancesLen += 1;

    if decl.variants.len > MAX_UNION_VARIANTS {

        panic "resolveUnionBody: maximum union variants exceeded";

    }

    let mut iota: u32 = 0;

        let case ast::NodeValue::UnionDeclVariant(variantDecl) = variantNode.value

            else panic "resolveUnionBody: invalid union variant";

        let variantName = try nodeName(self, variantDecl.name);

        // Resolve the variant's payload type if present.

        let mut variantType = Type::Void;

            }

        }

    }

    // Check that all variants are covered.

    if not state.catchAll {

            if not covered[i] {

                throw emitError(

                );

            }

        }

    } else if coveredCount == info.variants.len as u32 {

        throw emitError(self, node, ErrorKind::UnreachableElse);

    match pattern.value {

        case ast::NodeValue::Call(call) => {

            // Unlabeled patterns: `S(x, y)`.

            try checkRecordArity(self, call.args, recInfo, pattern);

                let fieldType = recInfo.fields[i].fieldType;

                try bindPatternVar(self, binding, fieldType, matchBy);

            }

        }

        case ast::NodeValue::RecordLit(lit) => {

        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {

            expected: info.paramTypes.len as u32,

            actual: call.args.len,

        }));

    }

        let expectedTy = *info.paramTypes[i];

        try checkAssignable(self, argNode, expectedTy);

    }

}

    }

}

/// Find a record field by name.

fn findRecordField(s: *RecordType, fieldName: *[u8]) -> ?u32 {

            if name == fieldName {

                return i;

            }

        }

    }

        let missingName = recordType.fields[lit.fields.len].name else panic;

        throw emitError(self, node, ErrorKind::RecordFieldMissing(missingName));

    }

    // Fields must be in declaration order.

        let case ast::NodeValue::RecordLitField(fieldArg) = fieldNode.value

            else panic "resolveRecordLit: expected field node value";

        let label = fieldArg.label

            else panic "resolveRecordLit: expected labeled field";

        let fieldName = try nodeName(self, label);

            }));

        }

    }

    // Fields must be in declaration order.

        let case ast::NodeValue::RecordLitField(fieldArg) = fieldNode.value

            else panic "resolveAnonRecordLit: expected field node value";

        let label = fieldArg.label

            else panic "resolveAnonRecordLit: expected labeled field";

        let fieldName = try nodeName(self, label);

        if let typeNode = clause.typeNode {

            // Typed catch clause: validate against callee's throw list.

            let errTy = try infer(self, typeNode);

            let mut foundIdx: ?u32 = nil;

                    foundIdx = j;

                    break;

                }

            }

            let idx = foundIdx else {

            io::print("?");

            printTypeBody(*inner, brief);

        }

        case super::Type::Fn(fnType) => {

            io::print("fn(");

                if i > 0 {

                    io::print(", ");

                }

            }

            io::print(")");

            io::print(" -> ");

            printTypeName(*fnType.returnType);

            if fnType.throwList.len > 0 {

                io::print(" throws ");

                    if i > 0 {

                        io::print(", ");

                    }

                }

            }

        }

        case super::Type::Nominal(info) => {

            if brief {

pub fn allocItems(a: *mut alloc::Arena, items: *[Expr]) -> *[Expr] {

    if items.len == 0 {

        return &[];

    }

    let buf = try! allocExprs(a, items.len);

    }

    return buf;

}

/// Allocate and copy prefix items followed by suffix items.

    let total = prefix.len + suffix.len;

    if total == 0 {

        return &[];

    }

    let buf = try! allocExprs(a, total);

    }

    }

    return buf;

}

/// Shorthand for creating a symbol.

            }

            write(out, ")");

        }

        case Expr::Vec { items } => {

            write(out, "[");

                    if i > 0 {

                        write(out, " ");

                    }

                }

            }

            write(out, "]");

        }

        case Expr::Block { name, items, children } => {