mir.rs

fn main() -> () {
    let var0: std::collections::hash::map::HashMap; // a
    let var1: &'static std::collections::hash::map::HashMap; // __arg0
    let mut tmp0: core::iter::Map, [closure@:4:41: 4:55]>;
    let mut tmp1: collections::vec::IntoIter;
    let mut tmp2: collections::vec::Vec;
    let mut tmp3: ();
    let mut tmp4: Box<[i32]>;
    let mut tmp5: Box<[i32; 4]>;
    let mut tmp6: Box<[i32; 4]>;
    let mut tmp7: [closure@:4:41: 4:55];
    let mut tmp8: ();
    let mut tmp9: core::fmt::Arguments;
    let mut tmp10: &'static [&'static str];
    let mut tmp11: &'static [&'static str];
    let mut tmp12: &'static [core::fmt::ArgumentV1];
    let mut tmp13: &'static [core::fmt::ArgumentV1; 1];
    let mut tmp14: &'static [core::fmt::ArgumentV1; 1];
    let mut tmp15: [core::fmt::ArgumentV1; 1];
    let mut tmp16: (&'static std::collections::hash::map::HashMap,);
    let mut tmp17: &'static std::collections::hash::map::HashMap;
    let mut tmp18: core::fmt::ArgumentV1;
    let mut tmp19: &'static std::collections::hash::map::HashMap;
    let mut tmp20: fn(&std::collections::hash::map::HashMap, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>;

    bb0: {
        tmp6 = Box([i32; 4]);
        (*tmp6) = [const 1i32, const 2i32, const 3i32, const 4i32];
        tmp5 = tmp6;
        tmp4 = tmp5 as Box<[i32]> (Unsize);
        tmp2 = collections::slice::[T]::into_vec(tmp4) -> [return: bb9, unwind: bb7];
    }

    bb1: {
        return;
    }

    bb2: {
        drop(var0) -> bb3;
    }

    bb3: {
        resume;
    }

    bb4: {
        drop(tmp2) -> bb5;
    }

    bb5: {
        drop(tmp1) -> bb6;
    }

    bb6: {
        drop(tmp0) -> bb2;
    }

    bb7: {
        drop(tmp5) -> bb8;
    }

    bb8: {
        drop(tmp4) -> bb4;
    }

    bb9: {
        tmp1 =  as core::iter::IntoIterator>::into_iter(tmp2) -> [return: bb10, unwind: bb7];
    }

    bb10: {
        tmp7 = [closure@:4:41: 4:55];
        tmp0 =  as core::iter::Iterator>::map::<(i32, i32), [closure@:4:41: 4:55]>(tmp1, tmp7) -> [return: bb11, unwind: bb7];
    }

    bb11: {
        var0 = , [closure@:4:41: 4:55]> as core::iter::Iterator>::collect::>(tmp0) -> [return: bb12, unwind: bb7];
    }

    bb12: {
        drop(tmp5) -> [return: bb13, unwind: bb8];
    }

    bb13: {
        drop(tmp4) -> [return: bb14, unwind: bb4];
    }

    bb14: {
        drop(tmp2) -> [return: bb15, unwind: bb5];
    }

    bb15: {
        drop(tmp1) -> [return: bb16, unwind: bb6];
    }

    bb16: {
        drop(tmp0) -> [return: bb17, unwind: bb2];
    }

    bb17: {
        tmp11 = &(*main::__STATIC_FMTSTR);
        tmp10 = &(*tmp11);
        tmp17 = &var0;
        tmp16 = (tmp17,);
        var1 = (tmp16.0: &std::collections::hash::map::HashMap);
        goto -> bb18;
    }

    bb18: {
        tmp19 = &(*var1);
        tmp20 =  as core::fmt::Debug>::fmt as fn(&std::collections::hash::map::HashMap, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error> (ReifyFnPointer);
        tmp18 = core::fmt::ArgumentV1<'a>::new::>(tmp19, tmp20) -> [return: bb20, unwind: bb2];
    }

    bb19: {
        tmp14 = &tmp15;
        tmp13 = &(*tmp14);
        tmp12 = tmp13 as &'static [core::fmt::ArgumentV1] (Unsize);
        tmp9 = core::fmt::Arguments<'a>::new_v1(tmp10, tmp12) -> [return: bb21, unwind: bb2];
    }

    bb20: {
        tmp15 = [tmp18];
        goto -> bb19;
    }

    bb21: {
        tmp8 = std::io::stdio::_print(tmp9) -> [return: bb22, unwind: bb2];
    }

    bb22: {
        drop(tmp8) -> [return: bb23, unwind: bb2];
    }

    bb23: {
        return = ();
        drop(var0) -> bb1;
    }
}
fn main(arg0: &'static mut [closure@:4:41: 4:55], arg1: i32) -> (i32, i32) {
    let var0: i32; // a
    let mut tmp0: i32;
    let mut tmp1: ();
    let mut tmp2: i32;
    let mut tmp3: i32;

    bb0: {
        var0 = arg1;
        tmp0 = var0;
        tmp3 = var0;
        tmp2 = Mul(tmp3, const 2i32);
        return = (tmp0, tmp2);
        goto -> bb1;
    }

    bb1: {
        return;
    }
}