# Final LLBC before serialization:

// Full name: core::fmt::Arguments
#[lang_item("format_arguments")]
pub opaque type Arguments<'a>

// 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::Tuple
#[lang_item("tuple_trait")]
pub trait Tuple<Self>
{
    proof ImpliedClause0: (Self: MetaSized)
    non-dyn-compatible
}

// Full name: core::ops::function::FnOnce
#[lang_item("fn_once")]
pub trait FnOnce<Self, Args>
{
    proof ImpliedClause0: (Self: MetaSized)
    proof ImpliedClause1: (Args: Sized)
    proof ImpliedClause2: (Args: Tuple)
    proof ImpliedClause3: (Self::Output: Sized)
    type Output
    fn call_once;
    vtable: core::ops::function::FnOnce::{vtable}<Args, Self::Output>
}

// Full name: core::option::Option
#[lang_item("Option")]
pub enum Option<T>
where
    TraitClause0: (T: Sized),
{
  None,
  Some(T),
}

// Full name: core::panicking::AssertKind
pub enum AssertKind {
  Eq,
  Ne,
  Match,
}

// Full name: take_mut::take
pub fn take<'_0, T, F>(_1: &'_0 mut T, _2: F)
where
    TraitClause0: (T: Sized),
    TraitClause1: (F: Sized),
    TraitClause2: (F: FnOnce<(T,)>),
    TypeConstraint0: TraitClause2::Output = T,
= <opaque>

// Full name: test_cargo_dependencies::main::silly_incr::closure
struct closure {}

// Full name: test_cargo_dependencies::main::silly_incr::{impl FnOnce<(u32,)> for closure}::call_once
fn call_once(_1: closure, tupled_args: (u32,)) -> u32
{
    let _0: u32; // return
    let _1: closure; // arg #1
    let tupled_args: (u32,); // arg #2
    let y: u32; // local
    let _4: u32; // anonymous local
    let _5: (u32, bool); // anonymous local

    storage_live(_0)
    storage_live(y)
    storage_live(_5)
    y = move tupled_args.0
    storage_live(_4)
    _4 = copy y
    _5 = copy _4 checked.+ const 1u32
    assert(move _5.1 == false) (overflow) else panic
    ↳⚡ storage_dead(_5)
        storage_dead(y)
        storage_dead(tupled_args)
        storage_dead(_1)
        unwind_continue
    _0 = move _5.0
    storage_dead(_4)
    storage_dead(_5)
    storage_dead(y)
    storage_dead(tupled_args)
    storage_dead(_1)
    return
}

// Full name: test_cargo_dependencies::main::silly_incr::{impl FnOnce<(u32,)> for closure}
impl "impl_FnOnce_tuple_for_closure" FnOnce<(u32,)> for closure {
    proof ImpliedClause0: (closure: MetaSized) = {built_in impl MetaSized for closure}
    proof ImpliedClause1: ((u32,): Sized) = {built_in impl Sized for (u32,)}
    proof ImpliedClause2: ((u32,): Tuple) = {built_in impl Tuple for (u32,)}
    proof ImpliedClause3: (u32: Sized) = {built_in impl Sized for u32}
    type Output = u32
    fn call_once = call_once
    non-dyn-compatible
}

// Full name: test_cargo_dependencies::main::silly_incr
fn silly_incr<'_0>(x: &'_0 mut u32)
{
    let _0: (); // return
    let x: &'1 mut u32; // arg #1
    let _2: (); // anonymous local
    let _3: &'2 mut u32; // anonymous local
    let _4: closure; // anonymous local

    storage_live(_0)
    _0 = ()
    storage_live(_2)
    storage_live(_3)
    _3 = &two-phase-mut (*x)
    storage_live(_4)
    _4 = closure {  }
    _2 = take<'4, u32, closure>[{built_in impl Sized for u32}, {built_in impl Sized for closure}, impl_FnOnce_tuple_for_closure](move _3, move _4)
    ↳⚡ storage_dead(x)
        unwind_continue
    storage_dead(_4)
    storage_dead(_3)
    storage_dead(_2)
    _0 = ()
    storage_dead(x)
    return
}

// Full name: test_cargo_dependencies::main
fn main()
{
    let _0: (); // return
    let x: u32; // local
    let _2: (); // anonymous local
    let _3: &'1 mut u32; // anonymous local
    let _4: &'2 mut u32; // anonymous local
    let _5: (&'6 u32, &'7 u32); // anonymous local
    let _6: &'8 u32; // anonymous local
    let _7: &'9 u32; // anonymous local
    let left_val: &'10 u32; // local
    let right_val: &'11 u32; // local
    let _10: bool; // anonymous local
    let _11: u32; // anonymous local
    let _12: u32; // anonymous local
    let kind: AssertKind; // local
    let _14: AssertKind; // anonymous local
    let _15: &'12 u32; // anonymous local
    let _16: &'13 u32; // anonymous local
    let _17: &'14 u32; // anonymous local
    let _18: &'15 u32; // anonymous local
    let _19: Option<Arguments<'22>>[{built_in impl Sized for Arguments<'22>}]; // anonymous local
    let _20: &'25 u32; // anonymous local
    let _21: &'28 u32; // anonymous local
    let _22: &'36 u32; // anonymous local
    let _23: u32; // anonymous local

    storage_live(_0)
    storage_live(_20)
    _0 = ()
    storage_live(x)
    x = const 0u32
    storage_live(_2)
    storage_live(_3)
    storage_live(_4)
    _4 = &mut x
    _3 = &two-phase-mut (*_4)
    _2 = silly_incr<'27>(move _3)
    ↳⚡ storage_dead(_20)
        storage_dead(_19)
        storage_dead(_18)
        storage_dead(_17)
        storage_dead(_16)
        storage_dead(_15)
        storage_dead(_14)
        storage_dead(kind)
        unwind_continue
    storage_live(_21)
    storage_live(_22)
    storage_live(_23)
    _23 = const 1u32
    _22 = &_23
    _21 = move _22
    storage_dead(_3)
    storage_dead(_4)
    storage_dead(_2)
    storage_live(_5)
    storage_live(_6)
    _6 = &x
    storage_live(_7)
    _20 = move _21
    _7 = &(*_20)
    _5 = (move _6, move _7)
    storage_dead(_7)
    storage_dead(_6)
    storage_live(left_val)
    left_val = copy _5.0
    storage_live(right_val)
    right_val = copy _5.1
    storage_live(_10)
    storage_live(_11)
    _11 = copy (*left_val)
    storage_live(_12)
    _12 = copy (*right_val)
    _10 = move _11 == move _12
    if move _10 {
    } else {
        storage_dead(_12)
        storage_dead(_11)
        storage_live(kind)
        kind = AssertKind::Eq {  }
        storage_live(_14)
        _14 = move kind
        storage_live(_15)
        storage_live(_16)
        _16 = &(*left_val)
        _15 = &(*_16)
        storage_live(_17)
        storage_live(_18)
        _18 = &(*right_val)
        _17 = &(*_18)
        storage_live(_19)
        _19 = Option::None {  }
        storage_dead(_20)
        storage_dead(_19)
        storage_dead(_18)
        storage_dead(_17)
        storage_dead(_16)
        storage_dead(_15)
        storage_dead(_14)
        storage_dead(kind)
        storage_dead(_23)
        storage_dead(_22)
        storage_dead(_21)
        panic(core::panicking::assert_failed)
    }
    storage_dead(_12)
    storage_dead(_11)
    storage_dead(_10)
    storage_dead(right_val)
    storage_dead(left_val)
    storage_dead(_5)
    _0 = ()
    storage_dead(x)
    storage_dead(_20)
    storage_dead(_19)
    storage_dead(_18)
    storage_dead(_17)
    storage_dead(_16)
    storage_dead(_15)
    storage_dead(_14)
    storage_dead(kind)
    storage_dead(_23)
    storage_dead(_22)
    storage_dead(_21)
    return
}



