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

            cases.append(il::SwitchCase {

            }, alloc::arenaAllocator(self.arena));

            cases.append(il::SwitchCase {

            }, alloc::arenaAllocator(self.arena));

    for c in cases {

        addPredecessor(self, BlockId(c.target), tagBlock);

        let caseBlock = BlockId(cases[i].target);

        if caseBlock <> mergeBlock {

//! returns: 0

//! Union equality handles every supported tag with mixed payload storage.

/// Union with the maximum supported variant count.

union Many: Copy {

    /// Variant 0 without a payload.

    V0,

    /// Variant 1 with a numeric payload.

    V1(u32),

    /// Variant 2 without a payload.

    V2,

    /// Variant 3 with a numeric payload.

    V3(u32),

    /// Variant 4 without a payload.

    V4,

    /// Variant 5 with a numeric payload.

    V5(u32),

    /// Variant 6 without a payload.

    V6,

    /// Variant 7 with a numeric payload.

    V7(u32),

    /// Variant 8 without a payload.

    V8,

    /// Variant 9 with a numeric payload.

    V9(u32),

    /// Variant 10 without a payload.

    V10,

    /// Variant 11 with a numeric payload.

    V11(u32),

    /// Variant 12 without a payload.

    V12,

    /// Variant 13 with a numeric payload.

    V13(u32),

    /// Variant 14 without a payload.

    V14,

    /// Variant 15 with a numeric payload.

    V15(u32),

    /// Variant 16 without a payload.

    V16,

    /// Variant 17 with a numeric payload.

    V17(u32),

    /// Variant 18 without a payload.

    V18,

    /// Variant 19 with a numeric payload.

    V19(u32),

    /// Variant 20 without a payload.

    V20,

    /// Variant 21 with a numeric payload.

    V21(u32),

    /// Variant 22 without a payload.

    V22,

    /// Variant 23 with a numeric payload.

    V23(u32),

    /// Variant 24 without a payload.

    V24,

    /// Variant 25 with a numeric payload.

    V25(u32),

    /// Variant 26 without a payload.

    V26,

    /// Variant 27 with a numeric payload.

    V27(u32),

    /// Variant 28 without a payload.

    V28,

    /// Variant 29 with a numeric payload.

    V29(u32),

    /// Variant 30 without a payload.

    V30,

    /// Variant 31 with a numeric payload.

    V31(u32),

    /// Variant 32 without a payload.

    V32,

    /// Variant 33 with a numeric payload.

    V33(u32),

    /// Variant 34 without a payload.

    V34,

    /// Variant 35 with a numeric payload.

    V35(u32),

    /// Variant 36 without a payload.

    V36,

    /// Variant 37 with a numeric payload.

    V37(u32),

    /// Variant 38 without a payload.

    V38,

    /// Variant 39 with a numeric payload.

    V39(u32),

    /// Variant 40 without a payload.

    V40,

    /// Variant 41 with a numeric payload.

    V41(u32),

    /// Variant 42 without a payload.

    V42,

    /// Variant 43 with a numeric payload.

    V43(u32),

    /// Variant 44 without a payload.

    V44,

    /// Variant 45 with a numeric payload.

    V45(u32),

    /// Variant 46 without a payload.

    V46,

    /// Variant 47 with a numeric payload.

    V47(u32),

    /// Variant 48 without a payload.

    V48,

    /// Variant 49 with a numeric payload.

    V49(u32),

    /// Variant 50 without a payload.

    V50,

    /// Variant 51 with a numeric payload.

    V51(u32),

    /// Variant 52 without a payload.

    V52,

    /// Variant 53 with a numeric payload.

    V53(u32),

    /// Variant 54 without a payload.

    V54,

    /// Variant 55 with a numeric payload.

    V55(u32),

    /// Variant 56 without a payload.

    V56,

    /// Variant 57 with a numeric payload.

    V57(u32),

    /// Variant 58 without a payload.

    V58,

    /// Variant 59 with a numeric payload.

    V59(u32),

    /// Variant 60 without a payload.

    V60,

    /// Variant 61 with a numeric payload.

    V61(u32),

    /// Variant 62 without a payload.

    V62,

    /// Variant 63 with a numeric payload.

    V63(u32),

    /// Variant 64 without a payload.

    V64,

    /// Variant 65 with a numeric payload.

    V65(u32),

    /// Variant 66 without a payload.

    V66,

    /// Variant 67 with a numeric payload.

    V67(u32),

    /// Variant 68 without a payload.

    V68,

    /// Variant 69 with a numeric payload.

    V69(u32),

    /// Variant 70 without a payload.

    V70,

    /// Variant 71 with a numeric payload.

    V71(u32),

    /// Variant 72 without a payload.

    V72,

    /// Variant 73 with a numeric payload.

    V73(u32),

    /// Variant 74 without a payload.

    V74,

    /// Variant 75 with a numeric payload.

    V75(u32),

    /// Variant 76 without a payload.

    V76,

    /// Variant 77 with a numeric payload.

    V77(u32),

    /// Variant 78 without a payload.

    V78,

    /// Variant 79 with a numeric payload.

    V79(u32),

    /// Variant 80 without a payload.

    V80,

    /// Variant 81 with a numeric payload.

    V81(u32),

    /// Variant 82 without a payload.

    V82,

    /// Variant 83 with a numeric payload.

    V83(u32),

    /// Variant 84 without a payload.

    V84,

    /// Variant 85 with a numeric payload.

    V85(u32),

    /// Variant 86 without a payload.

    V86,

    /// Variant 87 with a numeric payload.

    V87(u32),

    /// Variant 88 without a payload.

    V88,

    /// Variant 89 with a numeric payload.

    V89(u32),

    /// Variant 90 without a payload.

    V90,

    /// Variant 91 with a numeric payload.

    V91(u32),

    /// Variant 92 without a payload.

    V92,

    /// Variant 93 with a numeric payload.

    V93(u32),

    /// Variant 94 without a payload.

    V94,

    /// Variant 95 with a numeric payload.

    V95(u32),

    /// Variant 96 without a payload.

    V96,

    /// Variant 97 with a numeric payload.

    V97(u32),

    /// Variant 98 without a payload.

    V98,

    /// Variant 99 with a numeric payload.

    V99(u32),

    /// Variant 100 without a payload.

    V100,

    /// Variant 101 with a numeric payload.

    V101(u32),

    /// Variant 102 without a payload.

    V102,

    /// Variant 103 with a numeric payload.

    V103(u32),

    /// Variant 104 without a payload.

    V104,

    /// Variant 105 with a numeric payload.

    V105(u32),

    /// Variant 106 without a payload.

    V106,

    /// Variant 107 with a numeric payload.

    V107(u32),

    /// Variant 108 without a payload.

    V108,

    /// Variant 109 with a numeric payload.

    V109(u32),

    /// Variant 110 without a payload.

    V110,

    /// Variant 111 with a numeric payload.

    V111(u32),

    /// Variant 112 without a payload.

    V112,

    /// Variant 113 with a numeric payload.

    V113(u32),

    /// Variant 114 without a payload.

    V114,

    /// Variant 115 with a numeric payload.

    V115(u32),

    /// Variant 116 without a payload.

    V116,

    /// Variant 117 with a numeric payload.

    V117(u32),

    /// Variant 118 without a payload.

    V118,

    /// Variant 119 with a numeric payload.

    V119(u32),

    /// Variant 120 without a payload.

    V120,

    /// Variant 121 with a numeric payload.

    V121(u32),

    /// Variant 122 without a payload.

    V122,

    /// Variant 123 with a numeric payload.

    V123(u32),

    /// Variant 124 without a payload.

    V124,

    /// Variant 125 with a numeric payload.

    V125(u32),

    /// Variant 126 without a payload.

    V126,

    /// Variant 127 with a numeric payload.

    V127(u32),

}

/// Construct the selected variant and payload.

fn value(tag: u32, payload: u32) -> Many {

    match tag {

        case 0 => return Many::V0(),

        case 1 => return Many::V1(payload),

        case 2 => return Many::V2(),

        case 3 => return Many::V3(payload),

        case 4 => return Many::V4(),

        case 5 => return Many::V5(payload),

        case 6 => return Many::V6(),

        case 7 => return Many::V7(payload),

        case 8 => return Many::V8(),

        case 9 => return Many::V9(payload),

        case 10 => return Many::V10(),

        case 11 => return Many::V11(payload),

        case 12 => return Many::V12(),

        case 13 => return Many::V13(payload),

        case 14 => return Many::V14(),

        case 15 => return Many::V15(payload),

        case 16 => return Many::V16(),

        case 17 => return Many::V17(payload),

        case 18 => return Many::V18(),

        case 19 => return Many::V19(payload),

        case 20 => return Many::V20(),

        case 21 => return Many::V21(payload),

        case 22 => return Many::V22(),

        case 23 => return Many::V23(payload),

        case 24 => return Many::V24(),

        case 25 => return Many::V25(payload),

        case 26 => return Many::V26(),

        case 27 => return Many::V27(payload),

        case 28 => return Many::V28(),

        case 29 => return Many::V29(payload),

        case 30 => return Many::V30(),

        case 31 => return Many::V31(payload),

        case 32 => return Many::V32(),

        case 33 => return Many::V33(payload),

        case 34 => return Many::V34(),

        case 35 => return Many::V35(payload),

        case 36 => return Many::V36(),

        case 37 => return Many::V37(payload),

        case 38 => return Many::V38(),

        case 39 => return Many::V39(payload),

        case 40 => return Many::V40(),

        case 41 => return Many::V41(payload),

        case 42 => return Many::V42(),

        case 43 => return Many::V43(payload),

        case 44 => return Many::V44(),

        case 45 => return Many::V45(payload),

        case 46 => return Many::V46(),

        case 47 => return Many::V47(payload),

        case 48 => return Many::V48(),

        case 49 => return Many::V49(payload),

        case 50 => return Many::V50(),

        case 51 => return Many::V51(payload),

        case 52 => return Many::V52(),

        case 53 => return Many::V53(payload),

        case 54 => return Many::V54(),

        case 55 => return Many::V55(payload),

        case 56 => return Many::V56(),

        case 57 => return Many::V57(payload),

        case 58 => return Many::V58(),

        case 59 => return Many::V59(payload),

        case 60 => return Many::V60(),

        case 61 => return Many::V61(payload),

        case 62 => return Many::V62(),

        case 63 => return Many::V63(payload),

        case 64 => return Many::V64(),

        case 65 => return Many::V65(payload),

        case 66 => return Many::V66(),

        case 67 => return Many::V67(payload),

        case 68 => return Many::V68(),

        case 69 => return Many::V69(payload),

        case 70 => return Many::V70(),

        case 71 => return Many::V71(payload),

        case 72 => return Many::V72(),

        case 73 => return Many::V73(payload),

        case 74 => return Many::V74(),

        case 75 => return Many::V75(payload),

        case 76 => return Many::V76(),

        case 77 => return Many::V77(payload),

        case 78 => return Many::V78(),

        case 79 => return Many::V79(payload),

        case 80 => return Many::V80(),

        case 81 => return Many::V81(payload),

        case 82 => return Many::V82(),

        case 83 => return Many::V83(payload),

        case 84 => return Many::V84(),

        case 85 => return Many::V85(payload),

        case 86 => return Many::V86(),

        case 87 => return Many::V87(payload),

        case 88 => return Many::V88(),

        case 89 => return Many::V89(payload),

        case 90 => return Many::V90(),

        case 91 => return Many::V91(payload),

        case 92 => return Many::V92(),

        case 93 => return Many::V93(payload),

        case 94 => return Many::V94(),

        case 95 => return Many::V95(payload),

        case 96 => return Many::V96(),

        case 97 => return Many::V97(payload),

        case 98 => return Many::V98(),

        case 99 => return Many::V99(payload),

        case 100 => return Many::V100(),

        case 101 => return Many::V101(payload),

        case 102 => return Many::V102(),

        case 103 => return Many::V103(payload),

        case 104 => return Many::V104(),

        case 105 => return Many::V105(payload),

        case 106 => return Many::V106(),

        case 107 => return Many::V107(payload),

        case 108 => return Many::V108(),

        case 109 => return Many::V109(payload),

        case 110 => return Many::V110(),

        case 111 => return Many::V111(payload),

        case 112 => return Many::V112(),

        case 113 => return Many::V113(payload),

        case 114 => return Many::V114(),

        case 115 => return Many::V115(payload),

        case 116 => return Many::V116(),

        case 117 => return Many::V117(payload),

        case 118 => return Many::V118(),

        case 119 => return Many::V119(payload),

        case 120 => return Many::V120(),

        case 121 => return Many::V121(payload),

        case 122 => return Many::V122(),

        case 123 => return Many::V123(payload),

        case 124 => return Many::V124(),

        case 125 => return Many::V125(payload),

        case 126 => return Many::V126(),

        else => return Many::V127(payload),

    }

}

/// Compare runtime union values through the generated equality dispatch.

fn equal(a: Many, b: Many) -> bool {

    return a == b;

}

/// Check equal tags, differing tags, payload differences, and void cases.

@default fn main() -> u32 {

    for tag in 0..128 {

        assert equal(value(tag, 7), value(tag, 7));

        assert equal(value(tag, 7), value(tag, 8)) == (tag & 1 == 0);

        assert not equal(value(tag, 7), value((tag + 1) % 128, 7));

    }

    return 0;

}