// WARNING: This output format is intended for human consumers only
// and is subject to change without notice. Knock yourself out.
fn main() -> () {
    let mut _0: ();
    let _1: [u32; 2];
    let mut _3: std::mem::MaybeUninit<u32>;
    let mut _6: bool;
    let mut _7: usize;
    let mut _8: usize;
    let mut _9: usize;
    let mut _10: &[u32];
    let mut _11: &[u32; 2];
    let mut _12: (usize, bool);
    let mut _13: usize;
    let mut _14: &[std::mem::MaybeUninit<u32>];
    let mut _15: &[std::mem::MaybeUninit<u32>; 4];
    let mut _17: *mut std::mem::MaybeUninit<u32>;
    let mut _18: *mut std::mem::MaybeUninit<u32>;
    let mut _19: &mut [std::mem::MaybeUninit<u32>];
    let mut _20: &mut [std::mem::MaybeUninit<u32>; 4];
    let mut _21: usize;
    let _22: ();
    let mut _23: *const u32;
    let mut _24: &[u32];
    let mut _25: &[u32; 2];
    let mut _26: usize;
    let mut _27: &[u32];
    let mut _28: &[u32; 2];
    let mut _29: usize;
    let mut _30: &[u32];
    let mut _31: &[u32; 2];
    let mut _32: (usize, bool);
    let mut _34: std::mem::MaybeUninit<u32>;
    let mut _36: usize;
    let mut _37: usize;
    let mut _38: usize;
    let mut _39: &[u32];
    let mut _40: &[u32; 2];
    let mut _41: (usize, bool);
    let mut _42: usize;
    let mut _43: &[std::mem::MaybeUninit<u32>];
    let mut _44: &[std::mem::MaybeUninit<u32>; 3];
    scope 1 {
        debug extra => _1;
        let mut _2: [std::mem::MaybeUninit<u32>; 4];
        scope 2 {
            debug good_data => _2;
            let mut _4: usize;
            scope 3 {
                debug good_len => _4;
                let _5: std::option::Option<()>;
                let _16: *mut u32;
                scope 4 {
                    debug _good => _5;
                    let mut _33: [std::mem::MaybeUninit<u32>; 3];
                    scope 6 {
                        debug bad_data => _33;
                        scope 7 {
                            debug bad_len => const 2_usize;
                            let _35: bool;
                            scope 8 {
                                debug _bad => _35;
                            }
                        }
                    }
                }
                scope 5 {
                    debug dst => _16;
                }
            }
        }
    }

    bb0: {
        _1 = [const 1_u32, const 2_u32];
        _3 = MaybeUninit::<u32>::uninit() -> [return: bb1, unwind continue];
    }

    bb1: {
        _2 = [move _3; 4];
        _4 = const 1_usize;
        _8 = copy _4;
        _11 = &_1;
        _10 = move _11 as &[u32] (PointerCoercion(Unsize, Implicit));
        _9 = PtrMetadata(move _10);
        _12 = AddWithOverflow(copy _8, copy _9);
        assert(!move (_12.1: bool), "attempt to compute `{} + {}`, which would overflow", move _8, move _9) -> [success: bb2, unwind continue];
    }

    bb2: {
        _7 = move (_12.0: usize);
        _15 = &_2;
        _14 = move _15 as &[std::mem::MaybeUninit<u32>] (PointerCoercion(Unsize, Implicit));
        _13 = PtrMetadata(move _14);
        _6 = Le(move _7, move _13);
        switchInt(move _6) -> [0: bb9, otherwise: bb3];
    }

    bb3: {
        _20 = &mut _2;
        _19 = move _20 as &mut [std::mem::MaybeUninit<u32>] (PointerCoercion(Unsize, Implicit));
        _18 = core::slice::<impl [MaybeUninit<u32>]>::as_mut_ptr(move _19) -> [return: bb4, unwind continue];
    }

    bb4: {
        _21 = copy _4;
        _17 = std::ptr::mut_ptr::<impl *mut MaybeUninit<u32>>::add(move _18, move _21) -> [return: bb5, unwind continue];
    }

    bb5: {
        _16 = move _17 as *mut u32 (PtrToPtr);
        _25 = &_1;
        _24 = move _25 as &[u32] (PointerCoercion(Unsize, Implicit));
        _23 = core::slice::<impl [u32]>::as_ptr(move _24) -> [return: bb6, unwind continue];
    }

    bb6: {
        _28 = &_1;
        _27 = move _28 as &[u32] (PointerCoercion(Unsize, Implicit));
        _26 = PtrMetadata(move _27);
        _22 = copy_nonoverlapping::<u32>(move _23, copy _16, move _26) -> [return: bb7, unwind continue];
    }

    bb7: {
        _31 = &_1;
        _30 = move _31 as &[u32] (PointerCoercion(Unsize, Implicit));
        _29 = PtrMetadata(move _30);
        _32 = AddWithOverflow(copy _4, copy _29);
        assert(!move (_32.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _4, move _29) -> [success: bb8, unwind continue];
    }

    bb8: {
        _4 = move (_32.0: usize);
        _5 = Option::<()>::Some(const ());
        goto -> bb10;
    }

    bb9: {
        _5 = Option::<()>::None;
        goto -> bb10;
    }

    bb10: {
        _34 = MaybeUninit::<u32>::uninit() -> [return: bb11, unwind continue];
    }

    bb11: {
        _33 = [move _34; 3];
        _37 = const 2_usize;
        _40 = &_1;
        _39 = move _40 as &[u32] (PointerCoercion(Unsize, Implicit));
        _38 = PtrMetadata(move _39);
        _41 = AddWithOverflow(copy _37, copy _38);
        assert(!move (_41.1: bool), "attempt to compute `{} + {}`, which would overflow", move _37, move _38) -> [success: bb12, unwind continue];
    }

    bb12: {
        _36 = move (_41.0: usize);
        _44 = &_33;
        _43 = move _44 as &[std::mem::MaybeUninit<u32>] (PointerCoercion(Unsize, Implicit));
        _42 = PtrMetadata(move _43);
        _35 = Le(move _36, move _42);
        return;
    }
}

main::{constant#0}: usize = {
    let mut _0: usize;

    bb0: {
        _0 = const 4_usize;
        return;
    }
}

main::{constant#1}: usize = {
    let mut _0: usize;

    bb0: {
        _0 = const 3_usize;
        return;
    }
}
