# Final LLBC before serialization:

// Full name: core::marker::MetaSized
#[lang_item("meta_sized")]
pub trait MetaSized<Self>

// Full name: core::marker::Sized
#[lang_item("sized")]
pub trait Sized<Self>
{
    proof ImpliedClause0: (Self: MetaSized)
    non-dyn-compatible
}

// Full name: core::marker::Destruct
#[lang_item("destruct")]
pub trait Destruct<Self>
{
    fn drop_glue<'_0_1>;
    non-dyn-compatible
}

// Full name: core::ops::drop::Drop
#[lang_item("drop")]
pub trait Drop<Self>
{
    proof ImpliedClause0: (Self: MetaSized)
    fn drop<'_0_1> = core::ops::drop::Drop::drop<'_0_1, Self>[Self]
    vtable: core::ops::drop::Drop::{vtable}
}

pub fn core::ops::drop::Drop::drop<'_0, Self>(_1: &'_0 mut Self)
where
    TraitClause0: (Self: Drop),
= <opaque>

// Full name: alloc::alloc::Global
#[lang_item("global_alloc_ty")]
pub struct Global {}

// Full name: alloc::vec::Vec
#[lang_item("Vec")]
pub opaque type Vec<T>
where
    TraitClause0: (T: Sized),
    TraitClause1: (type_error("removed allocator parameter"): Sized),

// Full name: alloc::vec::Vec::{impl Destruct for Vec<T>[TraitClause0, TraitClause1]}::drop_glue
unsafe fn impl_Destruct_for_Vec::drop_glue<'_0, T, A>(_1: &'_0 mut Vec<T>[TraitClause0, TraitClause1])
where
    TraitClause0: (T: Sized),
    TraitClause1: (A: Sized),
= <opaque>

// Full name: test_crate::Foo
struct Foo<T>
where
    TraitClause0: (T: Sized),
{
  vec: Vec<T>[TraitClause0, {built_in impl Sized for Global}],
}

// Full name: test_crate::{impl Drop for Foo<T>[TraitClause0]}::drop
pub fn impl_Drop_for_Foo::drop<'_0, T>(self: &'_0 mut Foo<T>[TraitClause0])
where
    TraitClause0: (T: Sized),
{
    let _0: (); // return
    let self: &'1 mut Foo<T>[TraitClause0]; // arg #1

    storage_live(_0)
    _0 = ()
    _0 = ()
    storage_dead(self)
    return
}

// Full name: test_crate::Foo::{impl Destruct for Foo<T>[TraitClause0]}::drop_glue
unsafe fn impl_Destruct_for_Foo::drop_glue<'_0, T>(_1: &'_0 mut Foo<T>[TraitClause0])
where
    TraitClause0: (T: Sized),
{
    let _0: (); // return
    let _1: &'1 mut Foo<T>[TraitClause0]; // arg #1
    let _2: &'2 mut Foo<T>[TraitClause0]; // anonymous local
    let _3: (); // anonymous local

    storage_live(_0)
    storage_live(_2)
    storage_live(_3)
    _0 = ()
    _2 = &mut (*_1)
    _3 = impl_Drop_for_Foo::drop<'4, T>[TraitClause0](move _2)
    ↳⚡ drop[impl_Destruct_for_Vec::drop_glue<'5, T, Global>[TraitClause0, {built_in impl Sized for Global}]] ((*_1)).vec
        ↳⚡ storage_dead(_3)
            storage_dead(_2)
            storage_dead(_1)
            unwind_terminate
        storage_dead(_3)
        storage_dead(_2)
        storage_dead(_1)
        unwind_continue
    drop[impl_Destruct_for_Vec::drop_glue<'6, T, Global>[TraitClause0, {built_in impl Sized for Global}]] ((*_1)).vec
    ↳⚡ storage_dead(_3)
        storage_dead(_2)
        storage_dead(_1)
        unwind_continue
    storage_dead(_3)
    storage_dead(_2)
    storage_dead(_1)
    return
}

// Full name: test_crate::Foo::{impl Destruct for Foo<T>[TraitClause0]}
impl<T> "impl_Destruct_for_Foo" Destruct for Foo<T>[TraitClause0]
where
    TraitClause0: (T: Sized),
{
    fn drop_glue<'_0_1> = impl_Destruct_for_Foo::drop_glue<'_0_1, T>[TraitClause0]
    non-dyn-compatible
}

// Full name: test_crate::{impl Drop for Foo<T>[TraitClause0]}
impl<T> "impl_Drop_for_Foo" Drop for Foo<T>[TraitClause0]
where
    TraitClause0: (T: Sized),
{
    proof ImpliedClause0: (Foo<T>[TraitClause0]: MetaSized) = {built_in impl MetaSized for Foo<T>[TraitClause0]}
    fn drop<'_0_1> = impl_Drop_for_Foo::drop<'_0_1, T>[TraitClause0]
    vtable: impl_Drop_for_Foo::{vtable}<T>[TraitClause0]
}

// Full name: test_crate::drop_foo
fn drop_foo(_1: Foo<u32>[{built_in impl Sized for u32}])
{
    let _0: (); // return
    let _1: Foo<u32>[{built_in impl Sized for u32}]; // arg #1

    storage_live(_0)
    _0 = ()
    _0 = ()
    conditional_drop[impl_Destruct_for_Foo::drop_glue<'0, u32>[{built_in impl Sized for u32}]] _1
    ↳⚡ storage_dead(_1)
        unwind_continue
    storage_dead(_1)
    return
}



