//! returns: 0
//! Scalar match destinations cover table boundaries and large matches.

/// Select among 31 scalar cases and a fallback.
fn select31(value: u32) -> u32 {
    match value {
        case 0 => return 100,
        case 1 => return 101,
        case 2 => return 102,
        case 3 => return 103,
        case 4 => return 104,
        case 5 => return 105,
        case 6 => return 106,
        case 7 => return 107,
        case 8 => return 108,
        case 9 => return 109,
        case 10 => return 110,
        case 11 => return 111,
        case 12 => return 112,
        case 13 => return 113,
        case 14 => return 114,
        case 15 => return 115,
        case 16 => return 116,
        case 17 => return 117,
        case 18 => return 118,
        case 19 => return 119,
        case 20 => return 120,
        case 21 => return 121,
        case 22 => return 122,
        case 23 => return 123,
        case 24 => return 124,
        case 25 => return 125,
        case 26 => return 126,
        case 27 => return 127,
        case 28 => return 128,
        case 29 => return 129,
        case 30 => return 130,
        else => return 999,
    }
}

/// Select among 32 scalar cases and a fallback.
fn select32(value: u32) -> u32 {
    match value {
        case 0 => return 100,
        case 1 => return 101,
        case 2 => return 102,
        case 3 => return 103,
        case 4 => return 104,
        case 5 => return 105,
        case 6 => return 106,
        case 7 => return 107,
        case 8 => return 108,
        case 9 => return 109,
        case 10 => return 110,
        case 11 => return 111,
        case 12 => return 112,
        case 13 => return 113,
        case 14 => return 114,
        case 15 => return 115,
        case 16 => return 116,
        case 17 => return 117,
        case 18 => return 118,
        case 19 => return 119,
        case 20 => return 120,
        case 21 => return 121,
        case 22 => return 122,
        case 23 => return 123,
        case 24 => return 124,
        case 25 => return 125,
        case 26 => return 126,
        case 27 => return 127,
        case 28 => return 128,
        case 29 => return 129,
        case 30 => return 130,
        case 31 => return 131,
        else => return 999,
    }
}

/// Select among 64 scalar cases and a fallback.
fn select64(value: u32) -> u32 {
    match value {
        case 0 => return 100,
        case 1 => return 101,
        case 2 => return 102,
        case 3 => return 103,
        case 4 => return 104,
        case 5 => return 105,
        case 6 => return 106,
        case 7 => return 107,
        case 8 => return 108,
        case 9 => return 109,
        case 10 => return 110,
        case 11 => return 111,
        case 12 => return 112,
        case 13 => return 113,
        case 14 => return 114,
        case 15 => return 115,
        case 16 => return 116,
        case 17 => return 117,
        case 18 => return 118,
        case 19 => return 119,
        case 20 => return 120,
        case 21 => return 121,
        case 22 => return 122,
        case 23 => return 123,
        case 24 => return 124,
        case 25 => return 125,
        case 26 => return 126,
        case 27 => return 127,
        case 28 => return 128,
        case 29 => return 129,
        case 30 => return 130,
        case 31 => return 131,
        case 32 => return 132,
        case 33 => return 133,
        case 34 => return 134,
        case 35 => return 135,
        case 36 => return 136,
        case 37 => return 137,
        case 38 => return 138,
        case 39 => return 139,
        case 40 => return 140,
        case 41 => return 141,
        case 42 => return 142,
        case 43 => return 143,
        case 44 => return 144,
        case 45 => return 145,
        case 46 => return 146,
        case 47 => return 147,
        case 48 => return 148,
        case 49 => return 149,
        case 50 => return 150,
        case 51 => return 151,
        case 52 => return 152,
        case 53 => return 153,
        case 54 => return 154,
        case 55 => return 155,
        case 56 => return 156,
        case 57 => return 157,
        case 58 => return 158,
        case 59 => return 159,
        case 60 => return 160,
        case 61 => return 161,
        case 62 => return 162,
        case 63 => return 163,
        else => return 999,
    }
}

/// Multiple case values can share a destination and its merged value.
fn grouped(value: u32) -> u32 {
    let mut result: u32 = 0;
    match value {
        case 0, 2, 4, 6 => set result = 10,
        case 1, 3, 5, 7 => set result = 20,
        else => set result = 30,
    }
    return result + value;
}

/// Exercise every case and each fallback.
@default fn main() -> u32 {
    for value in 0..31 { assert select31(value) == value + 100; }
    assert select31(31) == 999;
    for value in 0..32 { assert select32(value) == value + 100; }
    assert select32(32) == 999;
    for value in 0..64 { assert select64(value) == value + 100; }
    assert select64(64) == 999;
    for value in 0..8 {
        let base: u32 = 10 if value % 2 == 0 else 20;
        assert grouped(value) == base + value;
    }
    assert grouped(8) == 38;
    return 0;
}