//! returns: 0
//! Array repeat literals of more than 32 scalar elements fill whole words and then the remaining
//! elements. The items are `u8`, `u16`, `u32`, and `u64` constants (zero, all ones, a mixed
//! pattern) and run-time values, for lengths around the word and chunk boundaries. Arrays inside
//! records start at an offset that is not a multiple of 8. Signed, boolean, scalar record, void
//! union, and function pointer items check the replicated bit pattern.

/// Number of stack bytes that `dirty` overwrites, as 32-bit words.
constant DIRTY_WORDS: u32 = 20000;

/// Check that every byte of a guard array still holds the value it was created with.
fn intact(guard: &[u8]) -> bool {
    for x in guard {
        if x <> 0x77 {
            return false;
        }
    }
    return true;
}

/// Overwrite the stack below the caller with values that no check expects. The next call that the
/// caller makes uses this stack, so its arrays start with these bytes.
fn dirty(seed: u32) -> u32 {
    let mut d: [u32; DIRTY_WORDS] = [0; DIRTY_WORDS];
    for i in 0 .. DIRTY_WORDS {
        set d[i] = 0xDEADBEEF + seed + i;
    }
    return d[seed % DIRTY_WORDS];
}

// U8 //

/// Build a run-time `u8` value with the high bit set.
fn mkU8(seed: u32) -> u8 {
    return (0x80 + seed * 7 + 1) as u8;
}

/// Check that every element of `items` equals `v`.
fn allU8(items: &[u8], v: u8) -> bool {
    for x in items {
        if x <> v {
            return false;
        }
    }
    return true;
}

/// Fill `[u8; 33]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_33(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 33] = [0; 33];
    let ones: [u8; 33] = [0xff; 33];
    let mid: [u8; 33] = [0x5a; 33];
    let run: [u8; 33] = [v; 33];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 34]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_34(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 34] = [0; 34];
    let ones: [u8; 34] = [0xff; 34];
    let mid: [u8; 34] = [0x5a; 34];
    let run: [u8; 34] = [v; 34];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 35]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_35(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 35] = [0; 35];
    let ones: [u8; 35] = [0xff; 35];
    let mid: [u8; 35] = [0x5a; 35];
    let run: [u8; 35] = [v; 35];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 36]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_36(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 36] = [0; 36];
    let ones: [u8; 36] = [0xff; 36];
    let mid: [u8; 36] = [0x5a; 36];
    let run: [u8; 36] = [v; 36];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 37]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_37(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 37] = [0; 37];
    let ones: [u8; 37] = [0xff; 37];
    let mid: [u8; 37] = [0x5a; 37];
    let run: [u8; 37] = [v; 37];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 38]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_38(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 38] = [0; 38];
    let ones: [u8; 38] = [0xff; 38];
    let mid: [u8; 38] = [0x5a; 38];
    let run: [u8; 38] = [v; 38];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 39]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_39(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 39] = [0; 39];
    let ones: [u8; 39] = [0xff; 39];
    let mid: [u8; 39] = [0x5a; 39];
    let run: [u8; 39] = [v; 39];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 40]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_40(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 40] = [0; 40];
    let ones: [u8; 40] = [0xff; 40];
    let mid: [u8; 40] = [0x5a; 40];
    let run: [u8; 40] = [v; 40];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 41]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_41(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 41] = [0; 41];
    let ones: [u8; 41] = [0xff; 41];
    let mid: [u8; 41] = [0x5a; 41];
    let run: [u8; 41] = [v; 41];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 47]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_47(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 47] = [0; 47];
    let ones: [u8; 47] = [0xff; 47];
    let mid: [u8; 47] = [0x5a; 47];
    let run: [u8; 47] = [v; 47];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 48]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_48(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 48] = [0; 48];
    let ones: [u8; 48] = [0xff; 48];
    let mid: [u8; 48] = [0x5a; 48];
    let run: [u8; 48] = [v; 48];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 49]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_49(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 49] = [0; 49];
    let ones: [u8; 49] = [0xff; 49];
    let mid: [u8; 49] = [0x5a; 49];
    let run: [u8; 49] = [v; 49];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 56]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_56(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 56] = [0; 56];
    let ones: [u8; 56] = [0xff; 56];
    let mid: [u8; 56] = [0x5a; 56];
    let run: [u8; 56] = [v; 56];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 57]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_57(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 57] = [0; 57];
    let ones: [u8; 57] = [0xff; 57];
    let mid: [u8; 57] = [0x5a; 57];
    let run: [u8; 57] = [v; 57];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 63]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_63(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 63] = [0; 63];
    let ones: [u8; 63] = [0xff; 63];
    let mid: [u8; 63] = [0x5a; 63];
    let run: [u8; 63] = [v; 63];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 64]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_64(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 64] = [0; 64];
    let ones: [u8; 64] = [0xff; 64];
    let mid: [u8; 64] = [0x5a; 64];
    let run: [u8; 64] = [v; 64];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 65]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_65(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 65] = [0; 65];
    let ones: [u8; 65] = [0xff; 65];
    let mid: [u8; 65] = [0x5a; 65];
    let run: [u8; 65] = [v; 65];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 1023]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_1023(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 1023] = [0; 1023];
    let ones: [u8; 1023] = [0xff; 1023];
    let mid: [u8; 1023] = [0x5a; 1023];
    let run: [u8; 1023] = [v; 1023];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 1024]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_1024(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 1024] = [0; 1024];
    let ones: [u8; 1024] = [0xff; 1024];
    let mid: [u8; 1024] = [0x5a; 1024];
    let run: [u8; 1024] = [v; 1024];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u8; 1025]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU8_1025(seed: u32) -> i32 {
    let v = mkU8(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u8; 1025] = [0; 1025];
    let ones: [u8; 1025] = [0xff; 1025];
    let mid: [u8; 1025] = [0x5a; 1025];
    let run: [u8; 1025] = [v; 1025];
    let after: [u8; 8] = [0x77; 8];
    if not allU8(&zero[..], 0) {
        return 1;
    }
    if not allU8(&ones[..], 0xff) {
        return 2;
    }
    if not allU8(&mid[..], 0x5a) {
        return 3;
    }
    if not allU8(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}
/// Record with an array that does not start at a multiple of 8 bytes.
record FrameU8_37: Copy {
    /// Byte before the array.
    head: u8,
    /// Repeated items.
    items: [u8; 37],
    /// Byte after the array.
    tail: u8,
}

/// Check `[u8; 37]` literals in a record literal and in assignments to the field.
fn frameU8_37(seed: u32) -> i32 {
    let v = mkU8(seed);
    let mut f = FrameU8_37 { head: 0x11, items: [v; 37], tail: 0x22 };
    if f.head <> 0x11 or f.tail <> 0x22 or not allU8(&f.items[..], v) {
        return 1;
    }
    set f.items = [0; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU8(&f.items[..], 0) {
        return 2;
    }
    set f.items = [0xff; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU8(&f.items[..], 0xff) {
        return 3;
    }
    let g = FrameU8_37 { head: 0x33, items: [0x5a; 37], tail: 0x44 };
    if g.head <> 0x33 or g.tail <> 0x44 or not allU8(&g.items[..], 0x5a) {
        return 4;
    }
    return 0;
}
/// Record with an array that does not start at a multiple of 8 bytes.
record FrameU8_41: Copy {
    /// Byte before the array.
    head: u8,
    /// Repeated items.
    items: [u8; 41],
    /// Byte after the array.
    tail: u8,
}

/// Check `[u8; 41]` literals in a record literal and in assignments to the field.
fn frameU8_41(seed: u32) -> i32 {
    let v = mkU8(seed);
    let mut f = FrameU8_41 { head: 0x11, items: [v; 41], tail: 0x22 };
    if f.head <> 0x11 or f.tail <> 0x22 or not allU8(&f.items[..], v) {
        return 1;
    }
    set f.items = [0; 41];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU8(&f.items[..], 0) {
        return 2;
    }
    set f.items = [0xff; 41];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU8(&f.items[..], 0xff) {
        return 3;
    }
    let g = FrameU8_41 { head: 0x33, items: [0x5a; 41], tail: 0x44 };
    if g.head <> 0x33 or g.tail <> 0x44 or not allU8(&g.items[..], 0x5a) {
        return 4;
    }
    return 0;
}

// U16 //

/// Build a run-time `u16` value with the high bit set.
fn mkU16(seed: u32) -> u16 {
    return (0x8001 + seed * 0x111) as u16;
}

/// Check that every element of `items` equals `v`.
fn allU16(items: &[u16], v: u16) -> bool {
    for x in items {
        if x <> v {
            return false;
        }
    }
    return true;
}

/// Fill `[u16; 33]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_33(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 33] = [0; 33];
    let ones: [u16; 33] = [0xffff; 33];
    let mid: [u16; 33] = [0x1234; 33];
    let run: [u16; 33] = [v; 33];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 34]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_34(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 34] = [0; 34];
    let ones: [u16; 34] = [0xffff; 34];
    let mid: [u16; 34] = [0x1234; 34];
    let run: [u16; 34] = [v; 34];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 35]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_35(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 35] = [0; 35];
    let ones: [u16; 35] = [0xffff; 35];
    let mid: [u16; 35] = [0x1234; 35];
    let run: [u16; 35] = [v; 35];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 36]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_36(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 36] = [0; 36];
    let ones: [u16; 36] = [0xffff; 36];
    let mid: [u16; 36] = [0x1234; 36];
    let run: [u16; 36] = [v; 36];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 37]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_37(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 37] = [0; 37];
    let ones: [u16; 37] = [0xffff; 37];
    let mid: [u16; 37] = [0x1234; 37];
    let run: [u16; 37] = [v; 37];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 40]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_40(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 40] = [0; 40];
    let ones: [u16; 40] = [0xffff; 40];
    let mid: [u16; 40] = [0x1234; 40];
    let run: [u16; 40] = [v; 40];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 63]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_63(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 63] = [0; 63];
    let ones: [u16; 63] = [0xffff; 63];
    let mid: [u16; 63] = [0x1234; 63];
    let run: [u16; 63] = [v; 63];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 64]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_64(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 64] = [0; 64];
    let ones: [u16; 64] = [0xffff; 64];
    let mid: [u16; 64] = [0x1234; 64];
    let run: [u16; 64] = [v; 64];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 65]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_65(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 65] = [0; 65];
    let ones: [u16; 65] = [0xffff; 65];
    let mid: [u16; 65] = [0x1234; 65];
    let run: [u16; 65] = [v; 65];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 1023]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_1023(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 1023] = [0; 1023];
    let ones: [u16; 1023] = [0xffff; 1023];
    let mid: [u16; 1023] = [0x1234; 1023];
    let run: [u16; 1023] = [v; 1023];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 1024]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_1024(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 1024] = [0; 1024];
    let ones: [u16; 1024] = [0xffff; 1024];
    let mid: [u16; 1024] = [0x1234; 1024];
    let run: [u16; 1024] = [v; 1024];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u16; 1025]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU16_1025(seed: u32) -> i32 {
    let v = mkU16(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u16; 1025] = [0; 1025];
    let ones: [u16; 1025] = [0xffff; 1025];
    let mid: [u16; 1025] = [0x1234; 1025];
    let run: [u16; 1025] = [v; 1025];
    let after: [u8; 8] = [0x77; 8];
    if not allU16(&zero[..], 0) {
        return 1;
    }
    if not allU16(&ones[..], 0xffff) {
        return 2;
    }
    if not allU16(&mid[..], 0x1234) {
        return 3;
    }
    if not allU16(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}
/// Record with an array that does not start at a multiple of 8 bytes.
record FrameU16_37: Copy {
    /// Byte before the array.
    head: u8,
    /// Repeated items.
    items: [u16; 37],
    /// Byte after the array.
    tail: u8,
}

/// Check `[u16; 37]` literals in a record literal and in assignments to the field.
fn frameU16_37(seed: u32) -> i32 {
    let v = mkU16(seed);
    let mut f = FrameU16_37 { head: 0x11, items: [v; 37], tail: 0x22 };
    if f.head <> 0x11 or f.tail <> 0x22 or not allU16(&f.items[..], v) {
        return 1;
    }
    set f.items = [0; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU16(&f.items[..], 0) {
        return 2;
    }
    set f.items = [0xffff; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU16(&f.items[..], 0xffff) {
        return 3;
    }
    let g = FrameU16_37 { head: 0x33, items: [0x1234; 37], tail: 0x44 };
    if g.head <> 0x33 or g.tail <> 0x44 or not allU16(&g.items[..], 0x1234) {
        return 4;
    }
    return 0;
}

// U32 //

/// Build a run-time `u32` value with the high bit set.
fn mkU32(seed: u32) -> u32 {
    return 0x89ABCDEF + seed;
}

/// Check that every element of `items` equals `v`.
fn allU32(items: &[u32], v: u32) -> bool {
    for x in items {
        if x <> v {
            return false;
        }
    }
    return true;
}

/// Fill `[u32; 33]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_33(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 33] = [0; 33];
    let ones: [u32; 33] = [0xffffffff; 33];
    let mid: [u32; 33] = [0x1234; 33];
    let run: [u32; 33] = [v; 33];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 34]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_34(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 34] = [0; 34];
    let ones: [u32; 34] = [0xffffffff; 34];
    let mid: [u32; 34] = [0x1234; 34];
    let run: [u32; 34] = [v; 34];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 35]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_35(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 35] = [0; 35];
    let ones: [u32; 35] = [0xffffffff; 35];
    let mid: [u32; 35] = [0x1234; 35];
    let run: [u32; 35] = [v; 35];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 36]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_36(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 36] = [0; 36];
    let ones: [u32; 36] = [0xffffffff; 36];
    let mid: [u32; 36] = [0x1234; 36];
    let run: [u32; 36] = [v; 36];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 37]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_37(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 37] = [0; 37];
    let ones: [u32; 37] = [0xffffffff; 37];
    let mid: [u32; 37] = [0x1234; 37];
    let run: [u32; 37] = [v; 37];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 40]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_40(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 40] = [0; 40];
    let ones: [u32; 40] = [0xffffffff; 40];
    let mid: [u32; 40] = [0x1234; 40];
    let run: [u32; 40] = [v; 40];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 63]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_63(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 63] = [0; 63];
    let ones: [u32; 63] = [0xffffffff; 63];
    let mid: [u32; 63] = [0x1234; 63];
    let run: [u32; 63] = [v; 63];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 64]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_64(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 64] = [0; 64];
    let ones: [u32; 64] = [0xffffffff; 64];
    let mid: [u32; 64] = [0x1234; 64];
    let run: [u32; 64] = [v; 64];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 65]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_65(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 65] = [0; 65];
    let ones: [u32; 65] = [0xffffffff; 65];
    let mid: [u32; 65] = [0x1234; 65];
    let run: [u32; 65] = [v; 65];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 1023]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_1023(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 1023] = [0; 1023];
    let ones: [u32; 1023] = [0xffffffff; 1023];
    let mid: [u32; 1023] = [0x1234; 1023];
    let run: [u32; 1023] = [v; 1023];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 1024]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_1024(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 1024] = [0; 1024];
    let ones: [u32; 1024] = [0xffffffff; 1024];
    let mid: [u32; 1024] = [0x1234; 1024];
    let run: [u32; 1024] = [v; 1024];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u32; 1025]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU32_1025(seed: u32) -> i32 {
    let v = mkU32(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u32; 1025] = [0; 1025];
    let ones: [u32; 1025] = [0xffffffff; 1025];
    let mid: [u32; 1025] = [0x1234; 1025];
    let run: [u32; 1025] = [v; 1025];
    let after: [u8; 8] = [0x77; 8];
    if not allU32(&zero[..], 0) {
        return 1;
    }
    if not allU32(&ones[..], 0xffffffff) {
        return 2;
    }
    if not allU32(&mid[..], 0x1234) {
        return 3;
    }
    if not allU32(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}
/// Record with an array that does not start at a multiple of 8 bytes.
record FrameU32_37: Copy {
    /// Byte before the array.
    head: u8,
    /// Repeated items.
    items: [u32; 37],
    /// Byte after the array.
    tail: u8,
}

/// Check `[u32; 37]` literals in a record literal and in assignments to the field.
fn frameU32_37(seed: u32) -> i32 {
    let v = mkU32(seed);
    let mut f = FrameU32_37 { head: 0x11, items: [v; 37], tail: 0x22 };
    if f.head <> 0x11 or f.tail <> 0x22 or not allU32(&f.items[..], v) {
        return 1;
    }
    set f.items = [0; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU32(&f.items[..], 0) {
        return 2;
    }
    set f.items = [0xffffffff; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU32(&f.items[..], 0xffffffff) {
        return 3;
    }
    let g = FrameU32_37 { head: 0x33, items: [0x1234; 37], tail: 0x44 };
    if g.head <> 0x33 or g.tail <> 0x44 or not allU32(&g.items[..], 0x1234) {
        return 4;
    }
    return 0;
}

// U64 //

/// Build a run-time `u64` value with the high bit set.
fn mkU64(seed: u32) -> u64 {
    return 0x8123456789ABCDEF + seed as u64;
}

/// Check that every element of `items` equals `v`.
fn allU64(items: &[u64], v: u64) -> bool {
    for x in items {
        if x <> v {
            return false;
        }
    }
    return true;
}

/// Fill `[u64; 33]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_33(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 33] = [0; 33];
    let ones: [u64; 33] = [0xffffffffffffffff; 33];
    let mid: [u64; 33] = [0x1234; 33];
    let run: [u64; 33] = [v; 33];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 34]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_34(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 34] = [0; 34];
    let ones: [u64; 34] = [0xffffffffffffffff; 34];
    let mid: [u64; 34] = [0x1234; 34];
    let run: [u64; 34] = [v; 34];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 35]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_35(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 35] = [0; 35];
    let ones: [u64; 35] = [0xffffffffffffffff; 35];
    let mid: [u64; 35] = [0x1234; 35];
    let run: [u64; 35] = [v; 35];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 36]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_36(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 36] = [0; 36];
    let ones: [u64; 36] = [0xffffffffffffffff; 36];
    let mid: [u64; 36] = [0x1234; 36];
    let run: [u64; 36] = [v; 36];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 37]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_37(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 37] = [0; 37];
    let ones: [u64; 37] = [0xffffffffffffffff; 37];
    let mid: [u64; 37] = [0x1234; 37];
    let run: [u64; 37] = [v; 37];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 40]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_40(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 40] = [0; 40];
    let ones: [u64; 40] = [0xffffffffffffffff; 40];
    let mid: [u64; 40] = [0x1234; 40];
    let run: [u64; 40] = [v; 40];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 1023]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_1023(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 1023] = [0; 1023];
    let ones: [u64; 1023] = [0xffffffffffffffff; 1023];
    let mid: [u64; 1023] = [0x1234; 1023];
    let run: [u64; 1023] = [v; 1023];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 1024]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_1024(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 1024] = [0; 1024];
    let ones: [u64; 1024] = [0xffffffffffffffff; 1024];
    let mid: [u64; 1024] = [0x1234; 1024];
    let run: [u64; 1024] = [v; 1024];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}

/// Fill `[u64; 1025]` arrays from constants and a run-time value, and check the elements and the
/// guards.
fn fillU64_1025(seed: u32) -> i32 {
    let v = mkU64(seed);
    let before: [u8; 8] = [0x77; 8];
    let zero: [u64; 1025] = [0; 1025];
    let ones: [u64; 1025] = [0xffffffffffffffff; 1025];
    let mid: [u64; 1025] = [0x1234; 1025];
    let run: [u64; 1025] = [v; 1025];
    let after: [u8; 8] = [0x77; 8];
    if not allU64(&zero[..], 0) {
        return 1;
    }
    if not allU64(&ones[..], 0xffffffffffffffff) {
        return 2;
    }
    if not allU64(&mid[..], 0x1234) {
        return 3;
    }
    if not allU64(&run[..], v) {
        return 4;
    }
    if not intact(&before[..]) or not intact(&after[..]) {
        return 5;
    }
    return 0;
}
/// Record with an array that does not start at a multiple of 8 bytes.
record FrameU64_37: Copy {
    /// Byte before the array.
    head: u8,
    /// Repeated items.
    items: [u64; 37],
    /// Byte after the array.
    tail: u8,
}

/// Check `[u64; 37]` literals in a record literal and in assignments to the field.
fn frameU64_37(seed: u32) -> i32 {
    let v = mkU64(seed);
    let mut f = FrameU64_37 { head: 0x11, items: [v; 37], tail: 0x22 };
    if f.head <> 0x11 or f.tail <> 0x22 or not allU64(&f.items[..], v) {
        return 1;
    }
    set f.items = [0; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU64(&f.items[..], 0) {
        return 2;
    }
    set f.items = [0xffffffffffffffff; 37];
    if f.head <> 0x11 or f.tail <> 0x22 or not allU64(&f.items[..], 0xffffffffffffffff) {
        return 3;
    }
    let g = FrameU64_37 { head: 0x33, items: [0x1234; 37], tail: 0x44 };
    if g.head <> 0x33 or g.tail <> 0x44 or not allU64(&g.items[..], 0x1234) {
        return 4;
    }
    return 0;
}
// Other scalars //

/// Scalar record of two bytes.
record Tag(u16): Copy;

/// Void union that lowers to one byte.
union Color: Copy {
    /// First.
    Red,
    /// Second.
    Green,
    /// Third.
    Blue,
}

/// Check signed items.
fn checkSigned(seed: u32) -> i32 {
    let n: i32 = 0 - 5 - seed as i32;
    let n8 = n as i8;
    let n16 = n as i16;
    let a: [i8; 40] = [-1; 40];
    let b: [i8; 40] = [-128; 40];
    let c: [i8; 40] = [n8; 40];
    for i in 0 .. 40 {
        if a[i] <> -1 or b[i] <> -128 or c[i] <> n8 {
            return 1;
        }
    }
    let d: [i16; 40] = [-2; 40];
    let e: [i16; 40] = [n16; 40];
    for i in 0 .. 40 {
        if d[i] <> -2 or e[i] <> n16 {
            return 2;
        }
    }
    let f: [i32; 40] = [-3; 40];
    let g: [i32; 40] = [n; 40];
    let h: [i64; 40] = [-4; 40];
    for i in 0 .. 40 {
        if f[i] <> -3 or g[i] <> n or h[i] <> -4 {
            return 3;
        }
    }
    return 0;
}

/// Return a constant, for the function pointer items.
fn five() -> u32 {
    return 5;
}

/// Check boolean, scalar record, void union, and function pointer items.
fn checkOther(seed: u32) -> i32 {
    let t: [bool; 40] = [true; 40];
    let u: [bool; 40] = [false; 40];
    let r: [bool; 40] = [seed == 1; 40];
    for i in 0 .. 40 {
        if not t[i] or u[i] or r[i] <> (seed == 1) {
            return 1;
        }
    }
    let tags: [Tag; 40] = [Tag(0x1234); 40];
    let colors: [Color; 40] = [Color::Blue; 40];
    let fns: [fn() -> u32; 40] = [five; 40];
    for i in 0 .. 40 {
        if *tags[i] <> 0x1234 {
            return 2;
        }
        if colors[i] <> Color::Blue {
            return 3;
        }
        if fns[i]() <> 5 {
            return 4;
        }
    }
    return 0;
}

@default fn main() -> i32 {
    let mut r: i32 = 0;
    for seed in 0 .. 3 {
        dirty(seed);
        set r = fillU8_33(seed);
        if r <> 0 {
            return 1 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_34(seed);
        if r <> 0 {
            return 2 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_35(seed);
        if r <> 0 {
            return 3 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_36(seed);
        if r <> 0 {
            return 4 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_37(seed);
        if r <> 0 {
            return 5 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_38(seed);
        if r <> 0 {
            return 6 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_39(seed);
        if r <> 0 {
            return 7 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_40(seed);
        if r <> 0 {
            return 8 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_41(seed);
        if r <> 0 {
            return 9 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_47(seed);
        if r <> 0 {
            return 10 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_48(seed);
        if r <> 0 {
            return 11 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_49(seed);
        if r <> 0 {
            return 12 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_56(seed);
        if r <> 0 {
            return 13 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_57(seed);
        if r <> 0 {
            return 14 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_63(seed);
        if r <> 0 {
            return 15 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_64(seed);
        if r <> 0 {
            return 16 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_65(seed);
        if r <> 0 {
            return 17 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_1023(seed);
        if r <> 0 {
            return 18 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_1024(seed);
        if r <> 0 {
            return 19 * 10 + r;
        }
        dirty(seed);
        set r = fillU8_1025(seed);
        if r <> 0 {
            return 20 * 10 + r;
        }
        dirty(seed);
        set r = frameU8_37(seed);
        if r <> 0 {
            return 21 * 10 + r;
        }
        dirty(seed);
        set r = frameU8_41(seed);
        if r <> 0 {
            return 22 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_33(seed);
        if r <> 0 {
            return 23 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_34(seed);
        if r <> 0 {
            return 24 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_35(seed);
        if r <> 0 {
            return 25 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_36(seed);
        if r <> 0 {
            return 26 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_37(seed);
        if r <> 0 {
            return 27 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_40(seed);
        if r <> 0 {
            return 28 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_63(seed);
        if r <> 0 {
            return 29 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_64(seed);
        if r <> 0 {
            return 30 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_65(seed);
        if r <> 0 {
            return 31 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_1023(seed);
        if r <> 0 {
            return 32 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_1024(seed);
        if r <> 0 {
            return 33 * 10 + r;
        }
        dirty(seed);
        set r = fillU16_1025(seed);
        if r <> 0 {
            return 34 * 10 + r;
        }
        dirty(seed);
        set r = frameU16_37(seed);
        if r <> 0 {
            return 35 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_33(seed);
        if r <> 0 {
            return 36 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_34(seed);
        if r <> 0 {
            return 37 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_35(seed);
        if r <> 0 {
            return 38 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_36(seed);
        if r <> 0 {
            return 39 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_37(seed);
        if r <> 0 {
            return 40 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_40(seed);
        if r <> 0 {
            return 41 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_63(seed);
        if r <> 0 {
            return 42 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_64(seed);
        if r <> 0 {
            return 43 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_65(seed);
        if r <> 0 {
            return 44 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_1023(seed);
        if r <> 0 {
            return 45 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_1024(seed);
        if r <> 0 {
            return 46 * 10 + r;
        }
        dirty(seed);
        set r = fillU32_1025(seed);
        if r <> 0 {
            return 47 * 10 + r;
        }
        dirty(seed);
        set r = frameU32_37(seed);
        if r <> 0 {
            return 48 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_33(seed);
        if r <> 0 {
            return 49 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_34(seed);
        if r <> 0 {
            return 50 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_35(seed);
        if r <> 0 {
            return 51 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_36(seed);
        if r <> 0 {
            return 52 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_37(seed);
        if r <> 0 {
            return 53 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_40(seed);
        if r <> 0 {
            return 54 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_1023(seed);
        if r <> 0 {
            return 55 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_1024(seed);
        if r <> 0 {
            return 56 * 10 + r;
        }
        dirty(seed);
        set r = fillU64_1025(seed);
        if r <> 0 {
            return 57 * 10 + r;
        }
        dirty(seed);
        set r = frameU64_37(seed);
        if r <> 0 {
            return 58 * 10 + r;
        }
        dirty(seed);
        set r = checkSigned(seed);
        if r <> 0 {
            return 59 * 10 + r;
        }
        dirty(seed);
        set r = checkOther(seed);
        if r <> 0 {
            return 60 * 10 + r;
        }
    }
    return 0;
}
