// MIR for `main` after SimplifyCfg-after-uninhabited-enum-branching

fn main() -> () {
    let mut _0: ();
    let _1: Plop;
    let mut _2: Test1;
    let _3: &str;
    let mut _4: &Test1;
    let mut _5: isize;
    let _6: &str;
    let _7: &str;
    let _8: &str;
    let _9: &str;
    let mut _10: isize;
    let _11: &str;
    let _12: &str;
    let _13: &str;
    scope 1 {
        debug plop => _1;
    }

    bb0: {
        StorageLive(_1);
        StorageLive(_2);
        _2 = Test1::C;
        _1 = Plop { xx: const 51_u32, test1: move _2 };
        StorageDead(_2);
        StorageLive(_3);
        StorageLive(_4);
        _4 = &(_1.1: Test1);
        _5 = discriminant((*_4));
        switchInt(move _5) -> [2: bb3, 3: bb1, otherwise: bb2];
    }

    bb1: {
        StorageLive(_8);
        _8 = const "D";
        _3 = &(*_8);
        StorageDead(_8);
        goto -> bb4;
    }

    bb2: {
        unreachable;
    }

    bb3: {
        StorageLive(_7);
        _7 = const "C";
        _3 = &(*_7);
        StorageDead(_7);
        goto -> bb4;
    }

    bb4: {
        StorageDead(_4);
        StorageDead(_3);
        StorageLive(_9);
        _10 = discriminant((_1.1: Test1));
        switchInt(move _10) -> [2: bb6, 3: bb5, otherwise: bb2];
    }

    bb5: {
        StorageLive(_13);
        _13 = const "D";
        _9 = &(*_13);
        StorageDead(_13);
        goto -> bb7;
    }

    bb6: {
        StorageLive(_12);
        _12 = const "C";
        _9 = &(*_12);
        StorageDead(_12);
        goto -> bb7;
    }

    bb7: {
        StorageDead(_9);
        _0 = const ();
        StorageDead(_1);
        return;
    }
}