};

        try testing::expect(failed);

        try testing::expect(arena.offset == 8);

    }

    set arena.offset = 8;

        let mut exhausted = false;

        try reader::storage(&mut input, 0xffffffff, 8, 0xffffffff) catch err {

            try testing::expect(err == binary::Error::Storage);

            set exhausted = true;

        };

/// Reject an invalid encoded instruction without a panic.

unsafe fn badInstruction(bytes: *[u8], expected: binary::Error) throws (testing::TestError) {

    let memory = &mut MEMORY[..64];

    let mut arena = alloc::new(&mut memory[..]);

        set input.registers = 2;

        set input.blocks = 1;

        let mut failed = false;

        try reader::instr(&mut input) catch err {

            try testing::expect(err == expected);

@test unsafe fn malformedInitializers() throws (testing::TestError) {

    let memory = &mut MEMORY[..8];

    let mut arena = alloc::new(&mut memory[..]);

    let fixtures: [*[u8]; 2] = [&[255], &[0, 3]];

    for bytes in &fixtures[..] {

            let mut failed = false;

            try reader::dataValue(&mut input) catch err {

                try testing::expect(err == binary::Error::Invalid);

                set failed = true;

            };

                throw binary::Error::Invalid;

            }

        }

        set symbols[i] = name;

    }

    }

}

/// Decode one package. Restore the arena offset on every failure.

/// The caller must retain the decoded allocations until the last package use.

export unsafe fn decode(bytes: &[u8], arena: &mut alloc::Arena, limits: binary::Limits)

    -> binary::Package throws (binary::Error)

{

    let saved = alloc::save(arena);

        return try readPackage(&mut input, limits) catch err {

            alloc::restore(arena, saved);

            throw err;

        };

    }

use std::lang::il;

use std::lang::il::binary;

use std::lang::alloc;

/// Input cursor and reconstruction storage.

export record Reader: 'input + Copy {

    /// Encoded bytes.

    bytes: &'input [u8],

    /// Number of bytes consumed.

    offset: u32,

    /// Storage for decoded sequences and byte strings.

    arena: *unsafe mut alloc::Arena,

    /// Symbol names in wire-index order.

    /// Exclusive bound for SSA register numbers.

    registers: u32,

    /// Number of blocks in the current function.

    blocks: u32,

}

/// Create a cursor. Set function bounds before reading instructions.

    return Reader 'input { bytes, offset: 0, arena, symbols, registers: 0, blocks: 0 };

}

/// Read an unsigned integer with width 1, 2, 4, or 8.

export fn integer 'input (input: &mut Reader 'input, width: u32) -> u64 throws (binary::Error) {

    set input.offset += n;

    return result;

}

/// Resolve a checked symbol-table index.

    let index = try integer(input, 4) as u32;

    if index >= input.symbols.len {

        throw binary::Error::Symbol;

    }

    return input.symbols[index];

    }

    return n;

}

/// Read a tagged value with checked register and symbol indices.

    let tag = try integer(input, 1) as u8;

    match tag {

        case super::VALUE_REG => return il::Val::Reg(try reg(input)),

        case super::VALUE_IMM => return il::Val::Imm(try integer(input, 8) as i64),

        case super::VALUE_DATASYM => return il::Val::DataSym(try symbol(input)),

/// A regional input buffer supports safe scalar decoding.

@test unsafe fn scalarReader() throws (testing::TestError) {

    let memory = &mut MEMORY[..];

    let mut arena = alloc::new(memory);

    let bytes: [u8; 8] = [1, 0, 0, 0, 2, 0, 0, 0];

        try checkScalarReader(&mut input);

    }

}

/// Check little-endian encoding for every integer width.

@test fn integers() throws (testing::TestError) {

    let mut buffer: [u8; 15] = [0; 15];

    let namesTable: [*[u8]; 0] = [];

    let storage: 'buffer = &mut buffer[..], names = &namesTable[..] in {

                try testing::expect(short.offset <= capacity);

            }

        }

        let memory = &mut MEMORY[..512];

        let mut arena = alloc::new(&mut memory[..]);

            set input.registers = 16;

            set input.blocks = 4;

            let decoded = try reader::instr(&mut input) catch {

                throw testing::TestError::Failed;

            };

                throw testing::TestError::Failed;

            };

            try testing::expectBytesEq(&out.bytes[..out.offset], expected);

            for length in 0..expected.len {

                alloc::reset(&mut arena);

                set input.registers = 16;

                set input.blocks = 4;

                let mut failed = false;

                try reader::instr(&mut input) catch err {

                    try testing::expect(err == binary::Error::Truncated);

            1, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

            2, 0, 0, 0, 0, 3, 1, 0, 0, 0, 4,

        ]);

        let memory = &mut MEMORY[..256];

        let mut arena = alloc::new(&mut memory[..]);

        set input.registers = 0x12345679;

        let empty = try reader::values(&mut input) catch {

            throw testing::TestError::Failed;

        };

        let decoded = try reader::values(&mut input) catch {