// MIR for `vec_move` after PreCodegen

fn vec_move(_1: Vec<impl Sized>) -> () {
    debug v => _1;
    let mut _0: ();
    let mut _22: std::vec::IntoIter<impl Sized>;
    let mut _23: std::vec::IntoIter<impl Sized>;
    let mut _24: &mut std::vec::IntoIter<impl Sized>;
    let mut _25: std::option::Option<impl Sized>;
    let mut _26: isize;
    let _28: ();
    scope 1 {
        debug iter => _23;
        let _27: impl Sized;
        scope 2 {
            debug x => _27;
        }
    }
    scope 3 (inlined <Vec<impl Sized> as IntoIterator>::into_iter) {
        debug self => _1;
        let _2: std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
        let mut _3: *const std::alloc::Global;
        let mut _8: usize;
        let mut _10: *mut impl Sized;
        let mut _11: *const impl Sized;
        let mut _12: usize;
        let _29: &std::vec::Vec<impl Sized>;
        let mut _30: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
        let mut _31: &alloc::raw_vec::RawVec<impl Sized>;
        let mut _32: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
        let _33: &std::vec::Vec<impl Sized>;
        let mut _34: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
        let _35: &std::vec::Vec<impl Sized>;
        let mut _36: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
        let mut _37: &alloc::raw_vec::RawVec<impl Sized>;
        let mut _38: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
        scope 4 {
            debug me => _2;
            scope 5 {
                debug alloc => const ManuallyDrop::<std::alloc::Global> {{ value: std::alloc::Global }};
                let _6: std::ptr::NonNull<impl Sized>;
                scope 6 {
                    debug buf => _6;
                    let _7: *mut impl Sized;
                    scope 7 {
                        debug begin => _7;
                        scope 8 {
                            debug end => _11;
                            let _20: usize;
                            scope 9 {
                                debug cap => _20;
                            }
                            scope 39 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
                                debug self => _38;
                            }
                            scope 40 (inlined alloc::raw_vec::RawVec::<impl Sized>::capacity) {
                                debug self => _37;
                                let mut _19: usize;
                                let mut _42: &alloc::raw_vec::RawVecInner;
                                scope 41 (inlined std::mem::size_of::<impl Sized>) {
                                }
                                scope 42 (inlined alloc::raw_vec::RawVecInner::capacity) {
                                    debug self => _42;
                                    debug elem_size => _19;
                                    let mut _21: core::num::niche_types::UsizeNoHighBit;
                                    scope 43 (inlined core::num::niche_types::UsizeNoHighBit::as_inner) {
                                        debug self => _21;
                                    }
                                }
                            }
                        }
                        scope 25 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
                            debug self => _34;
                        }
                        scope 26 (inlined Vec::<impl Sized>::len) {
                            debug self => _33;
                            let mut _13: bool;
                            scope 27 {
                            }
                        }
                        scope 28 (inlined std::ptr::mut_ptr::<impl *mut impl Sized>::wrapping_byte_add) {
                            debug self => _7;
                            debug count => _12;
                            let mut _14: *mut u8;
                            let mut _18: *mut u8;
                            scope 29 (inlined std::ptr::mut_ptr::<impl *mut impl Sized>::cast::<u8>) {
                                debug self => _7;
                            }
                            scope 30 (inlined std::ptr::mut_ptr::<impl *mut u8>::wrapping_add) {
                                debug self => _14;
                                debug count => _12;
                                let mut _15: isize;
                                scope 31 (inlined std::ptr::mut_ptr::<impl *mut u8>::wrapping_offset) {
                                    debug self => _14;
                                    debug count => _15;
                                    let mut _16: *const u8;
                                    let mut _17: *const u8;
                                }
                            }
                            scope 32 (inlined std::ptr::mut_ptr::<impl *mut u8>::with_metadata_of::<impl Sized>) {
                                debug self => _18;
                                debug meta => _5;
                                scope 33 (inlined std::ptr::metadata::<impl Sized>) {
                                    debug ptr => _5;
                                }
                                scope 34 (inlined std::ptr::from_raw_parts_mut::<impl Sized, ()>) {
                                }
                            }
                        }
                        scope 35 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
                            debug self => _36;
                        }
                        scope 36 (inlined Vec::<impl Sized>::len) {
                            debug self => _35;
                            let mut _9: bool;
                            scope 37 {
                            }
                        }
                        scope 38 (inlined #[track_caller] std::ptr::mut_ptr::<impl *mut impl Sized>::add) {
                            debug self => _7;
                            debug count => _8;
                        }
                    }
                    scope 24 (inlined NonNull::<impl Sized>::as_ptr) {
                        debug self => _6;
                    }
                }
                scope 17 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
                    debug self => _32;
                }
                scope 18 (inlined alloc::raw_vec::RawVec::<impl Sized>::non_null) {
                    debug self => _31;
                    let mut _41: &alloc::raw_vec::RawVecInner;
                    scope 19 (inlined alloc::raw_vec::RawVecInner::non_null::<impl Sized>) {
                        let mut _4: std::ptr::NonNull<u8>;
                        scope 20 (inlined Unique::<u8>::cast::<impl Sized>) {
                            scope 21 (inlined NonNull::<u8>::cast::<impl Sized>) {
                                let mut _5: *const impl Sized;
                                scope 22 (inlined NonNull::<u8>::as_ptr) {
                                }
                            }
                        }
                        scope 23 (inlined Unique::<impl Sized>::as_non_null_ptr) {
                        }
                    }
                }
            }
            scope 11 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
                debug self => _30;
            }
            scope 12 (inlined Vec::<impl Sized>::allocator) {
                debug self => _29;
                let mut _39: &alloc::raw_vec::RawVec<impl Sized>;
                scope 13 (inlined alloc::raw_vec::RawVec::<impl Sized>::allocator) {
                    let mut _40: &alloc::raw_vec::RawVecInner;
                    scope 14 (inlined alloc::raw_vec::RawVecInner::allocator) {
                    }
                }
            }
            scope 15 (inlined #[track_caller] std::ptr::read::<std::alloc::Global>) {
                debug src => _3;
            }
            scope 16 (inlined ManuallyDrop::<std::alloc::Global>::new) {
                debug value => const std::alloc::Global;
            }
        }
        scope 10 (inlined ManuallyDrop::<Vec<impl Sized>>::new) {
            debug value => _1;
        }
    }

    bb0: {
        StorageLive(_22);
        StorageLive(_29);
        StorageLive(_6);
        StorageLive(_7);
        StorageLive(_33);
        StorageLive(_11);
        StorageLive(_35);
        StorageLive(_20);
        StorageLive(_5);
        StorageLive(_4);
        StorageLive(_17);
        StorageLive(_2);
        _2 = ManuallyDrop::<Vec<impl Sized>> { value: copy _1 };
        StorageLive(_3);
        StorageLive(_30);
        // DBG: _30 = &_2;
        // DBG: _29 = &(_2.0: std::vec::Vec<impl Sized>);
        StorageDead(_30);
        StorageLive(_39);
        // DBG: _39 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
        StorageLive(_40);
        // DBG: _40 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
        StorageDead(_40);
        StorageDead(_39);
        _3 = &raw const ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global);
        StorageDead(_3);
        StorageLive(_31);
        StorageLive(_32);
        // DBG: _32 = &_2;
        StorageDead(_32);
        // DBG: _31 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
        StorageLive(_41);
        // DBG: _41 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
        _4 = copy (((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
        _5 = copy _4 as *const impl Sized (Transmute);
        _6 = NonNull::<impl Sized> { pointer: copy _5 };
        StorageDead(_41);
        StorageDead(_31);
        _7 = copy _4 as *mut impl Sized (Transmute);
        switchInt(const <impl Sized as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
    }

    bb1: {
        StorageLive(_10);
        StorageLive(_8);
        StorageLive(_36);
        // DBG: _36 = &_2;
        // DBG: _35 = &(_2.0: std::vec::Vec<impl Sized>);
        StorageDead(_36);
        _8 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
        StorageLive(_9);
        _9 = Le(copy _8, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
        assume(move _9);
        StorageDead(_9);
        _10 = Offset(copy _7, copy _8);
        _11 = copy _10 as *const impl Sized (PtrToPtr);
        StorageDead(_8);
        StorageDead(_10);
        goto -> bb4;
    }

    bb2: {
        StorageLive(_12);
        StorageLive(_34);
        // DBG: _34 = &_2;
        // DBG: _33 = &(_2.0: std::vec::Vec<impl Sized>);
        StorageDead(_34);
        _12 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
        StorageLive(_13);
        _13 = Le(copy _12, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
        assume(move _13);
        StorageDead(_13);
        StorageLive(_18);
        StorageLive(_14);
        _14 = copy _4 as *mut u8 (Transmute);
        StorageLive(_15);
        _15 = copy _12 as isize (IntToInt);
        StorageLive(_16);
        _16 = copy _4 as *const u8 (Transmute);
        _17 = arith_offset::<u8>(move _16, move _15) -> [return: bb3, unwind unreachable];
    }

    bb3: {
        StorageDead(_16);
        _18 = copy _17 as *mut u8 (PtrToPtr);
        StorageDead(_15);
        StorageDead(_14);
        StorageDead(_18);
        StorageDead(_12);
        _11 = copy _17 as *const impl Sized (PtrToPtr);
        goto -> bb4;
    }

    bb4: {
        StorageLive(_37);
        StorageLive(_38);
        // DBG: _38 = &_2;
        StorageDead(_38);
        // DBG: _37 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
        StorageLive(_42);
        // DBG: _42 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
        StorageLive(_19);
        _19 = SizeOf(impl Sized);
        switchInt(move _19) -> [0: bb5, otherwise: bb6];
    }

    bb5: {
        _20 = const usize::MAX;
        goto -> bb7;
    }

    bb6: {
        StorageLive(_21);
        _21 = copy ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).1: core::num::niche_types::UsizeNoHighBit);
        _20 = copy _21 as usize (Transmute);
        StorageDead(_21);
        goto -> bb7;
    }

    bb7: {
        StorageDead(_19);
        StorageDead(_42);
        StorageDead(_37);
        _22 = std::vec::IntoIter::<impl Sized> { buf: copy _6, phantom: const ZeroSized: PhantomData<impl Sized>, cap: move _20, alloc: const ManuallyDrop::<std::alloc::Global> {{ value: std::alloc::Global }}, ptr: copy _6, end: copy _11 };
        StorageDead(_2);
        StorageDead(_17);
        StorageDead(_4);
        StorageDead(_5);
        StorageDead(_20);
        StorageDead(_35);
        StorageDead(_11);
        StorageDead(_33);
        StorageDead(_7);
        StorageDead(_6);
        StorageDead(_29);
        StorageLive(_23);
        _23 = move _22;
        goto -> bb8;
    }

    bb8: {
        StorageLive(_25);
        _24 = &mut _23;
        _25 = <std::vec::IntoIter<impl Sized> as Iterator>::next(move _24) -> [return: bb9, unwind: bb15];
    }

    bb9: {
        _26 = discriminant(_25);
        switchInt(move _26) -> [0: bb10, 1: bb12, otherwise: bb14];
    }

    bb10: {
        StorageDead(_25);
        drop(_23) -> [return: bb11, unwind continue];
    }

    bb11: {
        StorageDead(_23);
        StorageDead(_22);
        return;
    }

    bb12: {
        _27 = move ((_25 as Some).0: impl Sized);
        _28 = opaque::<impl Sized>(move _27) -> [return: bb13, unwind: bb15];
    }

    bb13: {
        StorageDead(_25);
        goto -> bb8;
    }

    bb14: {
        unreachable;
    }

    bb15 (cleanup): {
        drop(_23) -> [return: bb16, unwind terminate(cleanup)];
    }

    bb16 (cleanup): {
        resume;
    }
}