/// Register holding the first element address.

    /// Number of elements in the range.

    /// Available capacity from the first element address.

    capacity: il::Val,

    let mut capacity: il::Val = undefined;

        set capacity = containerLen;

        set capacity = loadSliceCap(self, baseReg);

        if capacity == endVal {

            set capacity = count;

        } else {

            set capacity = emitTypedBinOp(self, il::BinOp::Sub, il::Type::W32, capacity, startVal);

        }

    return SliceRangeResult { dataReg, count, capacity };

        self, info.itemType, info.mutable, il::Val::Reg(r.dataReg), r.count, r.capacity

    store w32 4 %3 12;

//! returns: 133

//! Slice range bounds use length even when capacity is larger.

/// Preserve a dynamic range bound.

fn bound(value: u32) -> u32 {

    return value;

}

@default fn main() -> i32 {

    let storage: [i32; 4] = [10, 20, 30, 40];

    let prefix = &storage[..1];

    let invalid = &prefix[..bound(2)];

    return invalid.len as i32;

}

//! returns: 0

//! Slice ranges retain the backing capacity after their start offset.

/// Allocator interface used by append.

record Allocator: Copy {

    /// Allocation callback.

    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque,

    /// Callback context.

    ctx: *unsafe mut opaque,

}

/// Reject allocation when append must use existing storage.

unsafe fn rejectAlloc(ctx: *unsafe mut opaque, size: u32, alignment: u32) -> *mut opaque {

    panic "rejectAlloc: unexpected allocation";

}

/// Check dynamic range bounds and nested slice capacity.

fn checkRange(storage: *mut [i32], start: u32, end: u32) {

    let cap = storage.cap;

    let part: *mut [i32] = &mut storage[start..end];

    assert part.len == end - start;

    assert part.cap == cap - start;

    let empty = &mut part[..0];

    assert empty.len == 0;

    assert empty.cap == part.cap;

}

@default unsafe fn main() -> i32 {

    static storage: [i32; 4] = [10, 20, 30, 40];

    let empty = &mut storage[..0];

    assert empty.len == 0;

    assert empty.cap == 4;

    let prefix = &storage[..2];

    assert prefix.len == 2;

    assert prefix.cap == 4;

    let middle = &storage[1..2];

    assert middle.len == 1;

    assert middle.cap == 3;

    assert middle[0] == 20;

    let tail = &storage[2..];

    assert tail.len == 2;

    assert tail.cap == 2;

    let end = &storage[4..4];

    assert end.len == 0;

    assert end.cap == 0;

    checkRange((&mut storage[..2]) as *mut [i32], 1, 2);

    checkRange((&mut storage[..]) as *mut [i32], 4, 4);

    let mut items: *mut [i32] = &mut storage[1..1];

    let allocator = Allocator { func: rejectAlloc, ctx: &mut storage as *unsafe mut opaque };

    items.append(50, allocator);

    items.append(60, allocator);

    items.append(70, allocator);

    assert items.len == 3;

    assert items.cap == 3;

    assert items[0] == 50;

    assert items[2] == 70;

    return 0;

}

    load w32 %6 %1 12;

    mul w64 %7 %2 4;

    add w64 %8 %4 %7;

    sub w32 %9 %3 %2;

    sub w32 %10 %6 %2;

    reserve %11 16 8;

    store w64 %8 %11 0;

    store w32 %9 %11 8;

    store w32 %10 %11 12;

    blit %0 %11 16;

    load w32 %5 %1 12;

    mul w64 %6 %2 4;

    add w64 %7 %3 %6;

    sub w32 %8 %4 %2;

    sub w32 %9 %5 %2;

    reserve %10 16 8;

    store w64 %7 %10 0;

    store w32 %8 %10 8;

    store w32 %9 %10 12;

    blit %0 %10 16;

    load w32 %5 %1 12;

    reserve %6 16 8;

    store w64 %3 %6 0;

    store w32 %2 %6 8;

    store w32 %5 %6 12;

    blit %0 %6 16;

    load w32 %4 %1 12;

    reserve %5 16 8;

    store w64 %2 %5 0;

    store w32 %3 %5 8;

    store w32 %4 %5 12;

    blit %0 %5 16;

    sub w32 %5 4 1;

    reserve %6 16 8;

    store w64 %3 %6 0;

    store w32 %4 %6 8;

    store w32 %5 %6 12;

    blit %0 %6 16;