[Debug] 
struct test1::Pair<T1, T2>{
  x : T1,
  y : T2}

enum test1::List<T> =
|  Cons(0 : T, 1 : std::boxed::Box<test1::List<T>>)
|  Nil()

enum test1::One<T1> =
|  One(0 : T1)

enum test1::EmptyEnum =
|  Empty()

enum test1::Enum =
|  Variant1()
|  Variant2()

struct test1::EmptyStruct{}

enum test1::Sum<T1, T2> =
|  Left(0 : T1)
|  Right(0 : T2)

fn add_test(x : u32, y : u32) -> u32 {
  var@0 : u32;
  x : u32;
  y : u32;
  var@3 : u32;
  var@4 : u32;
  var@5 : (u32, bool);

  var@3 := copy x
  var@4 := copy y
  var@0 := copy var@3 + copy var@4
  return
}

fn subs_test(x : u32, y : u32) -> u32 {
  var@0 : u32;
  x : u32;
  y : u32;
  var@3 : u32;
  var@4 : u32;
  var@5 : (u32, bool);

  var@3 := copy x
  var@4 := copy y
  var@0 := copy var@3 - copy var@4
  return
}

fn div_test(x : u32, y : u32) -> u32 {
  var@0 : u32;
  x : u32;
  y : u32;
  var@3 : u32;
  var@4 : u32;
  var@5 : bool;

  var@3 := copy x
  var@4 := copy y
  var@0 := move var@3 / move var@4
  return
}

fn rem_test(x : u32, y : u32) -> u32 {
  var@0 : u32;
  x : u32;
  y : u32;
  var@3 : u32;
  var@4 : u32;
  var@5 : bool;

  var@3 := copy x
  var@4 := copy y
  var@0 := move var@3 % move var@4
  return
}

fn test2() {
  var@0 : ();
  x : u32;
  y : u32;
  z : u32;
  p : test1::Pair<u32, u32>;
  var@5 : u32;
  s : test1::Sum<u32, bool>;
  o : test1::One<u64>;
  e0 : test1::EmptyEnum;
  e1 : test1::EmptyEnum;
  enum0 : test1::Enum;

  x := 23: u32
  y := 44: u32
  z := 67: u32
  var@5 := copy x
  (p).x := move var@5
  (p).y := 67: u32
  (s as test1::Sum::Right).0 := true
  set_discriminant(s, 1)
  (o as test1::One::One).0 := 3: u64
  set_discriminant(o, 0)
  set_discriminant(e0, 0)
  set_discriminant(enum0, 0)
  return
}

fn get_max(x : u32, y : u32) -> u32 {
  var@0 : u32;
  x : u32;
  y : u32;
  var@3 : bool;
  var@4 : u32;
  var@5 : u32;

  var@4 := copy x
  var@5 := copy y
  var@3 := move var@4 >= move var@5
  if (move var@3) {
    var@0 := copy x
  }
  else {
    var@0 := copy y
  }
  return
}

fn test3() {
  var@0 : ();
  x : u32;
  y : u32;
  z : u32;
  var@4 : u32;
  var@5 : u32;
  var@6 : (u32, bool);
  var@7 : bool;
  var@8 : bool;
  var@9 : u32;

  x := move get_max(4: u32, 3: u32)
  y := move get_max(10: u32, 11: u32)
  var@4 := copy x
  var@5 := copy y
  z := copy var@4 + copy var@5
  var@9 := copy z
  var@8 := move var@9 == 15: u32
  var@7 := ¬ move var@8
  assert(¬move var@7)
  return
}

fn test_neg(x : i32) -> i32 {
  var@0 : i32;
  x : i32;
  var@2 : i32;
  var@3 : bool;

  var@2 := copy x
  var@3 := copy var@2 == -2147483648: i32
  assert(¬move var@3)
  var@0 := - move var@2
  return
}

fn test_neg1() {
  var@0 : ();
  x : i32;
  y : i32;

  x := 3: i32
  y := -3: i32
  return
}

fn refs_test1() {
  var@0 : ();
  x : i32;
  px : &'_ mut (i32);
  ppx : &'_ mut (&'_ mut (i32));
  var@4 : bool;
  var@5 : bool;
  var@6 : i32;

  x := 0: i32
  px := &mut x
  ppx := &mut px
  *(*(ppx)) := 1: i32
  var@6 := copy x
  var@5 := move var@6 == 1: i32
  var@4 := ¬ move var@5
  assert(¬move var@4)
  return
}

fn refs_test2() {
  var@0 : ();
  x : i32;
  y : i32;
  px : &'_ mut (i32);
  py : &'_ mut (i32);
  ppx : &'_ mut (&'_ mut (i32));
  var@6 : &'_ mut (i32);
  var@7 : bool;
  var@8 : bool;
  var@9 : i32;
  var@10 : bool;
  var@11 : bool;
  var@12 : i32;
  var@13 : bool;
  var@14 : bool;
  var@15 : i32;
  var@16 : bool;
  var@17 : bool;
  var@18 : i32;

  x := 0: i32
  y := 1: i32
  px := &mut x
  py := &mut y
  ppx := &mut px
  var@6 := &mut *(py)
  *(ppx) := move var@6
  *(*(ppx)) := 2: i32
  var@9 := copy *(px)
  var@8 := move var@9 == 2: i32
  var@7 := ¬ move var@8
  assert(¬move var@7)
  var@12 := copy x
  var@11 := move var@12 == 0: i32
  var@10 := ¬ move var@11
  assert(¬move var@10)
  var@15 := copy *(py)
  var@14 := move var@15 == 2: i32
  var@13 := ¬ move var@14
  assert(¬move var@13)
  var@18 := copy y
  var@17 := move var@18 == 2: i32
  var@16 := ¬ move var@17
  assert(¬move var@16)
  return
}

fn test_list1() {
  var@0 : ();
  l : test1::List<i32>;
  var@2 : std::boxed::Box<test1::List<i32>>;
  var@3 : test1::List<i32>;

  set_discriminant(var@3, 1)
  var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
  (l as test1::List::Cons).0 := 0: i32
  (l as test1::List::Cons).1 := move var@2
  set_discriminant(l, 0)
drop(l)
  return
}

fn test_box1() {
  var@0 : ();
  b : std::boxed::Box<i32>;
  x : &'_ mut (i32);
  var@3 : &'_ mut (std::boxed::Box<i32>);
  x : &'_ (i32);
  var@5 : &'_ (std::boxed::Box<i32>);
  var@6 : bool;
  var@7 : bool;
  var@8 : i32;

  b := move alloc::boxed::Box<i32>::new(0: i32)
  var@3 := &two-phase b
  x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3)
  *(x) := 1: i32
  var@5 := &b
  x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)
  var@8 := copy *(x)
  var@7 := move var@8 == 1: i32
  var@6 := ¬ move var@7
  assert(¬move var@6)
drop(b)
  return
}

fn copy_int(x : i32) -> i32 {
  var@0 : i32;
  x : i32;

  var@0 := copy x
  return
}

fn test_copy_int() {
  var@0 : ();
  x : i32;
  px : &'_ (i32);
  y : i32;
  var@4 : i32;
  var@5 : bool;
  var@6 : bool;
  var@7 : i32;
  var@8 : i32;

  x := 0: i32
  px := &x
  var@4 := copy x
  y := move copy_int(move var@4)
  var@7 := copy *(px)
  var@8 := copy y
  var@6 := move var@7 == move var@8
  var@5 := ¬ move var@6
  assert(¬move var@5)
  return
}

fn is_cons<0,T>(l : &0 (test1::List<T>)) -> bool {
  var@0 : bool;
  l : &'_ (test1::List<T>);
  var@2 : isize;

  var@2 := discriminant(*(l))
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  }
  return
}

fn test_is_cons() {
  var@0 : ();
  l : test1::List<i32>;
  var@2 : std::boxed::Box<test1::List<i32>>;
  var@3 : test1::List<i32>;
  var@4 : bool;
  var@5 : bool;
  var@6 : &'_ (test1::List<i32>);
  var@7 : &'_ (test1::List<i32>);

  set_discriminant(var@3, 1)
  var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
  (l as test1::List::Cons).0 := 0: i32
  (l as test1::List::Cons).1 := move var@2
  set_discriminant(l, 0)
  var@7 := &l
  var@6 := copy var@7
  var@5 := move is_cons<i32>(move var@6)
  var@4 := ¬ move var@5
  assert(¬move var@4)
drop(l)
  return
}

fn split_list<T>(l : test1::List<T>) -> (T, test1::List<T>) {
  var@0 : (T, test1::List<T>);
  l : test1::List<T>;
  var@2 : isize;
  hd : T;
  tl : std::boxed::Box<test1::List<T>>;
  var@5 : T;
  var@6 : test1::List<T>;
  var@7 : bool;
  var@8 : bool;
  var@9 : ();
  var@10 : isize;

  var@8 := false
  var@7 := false
  var@7 := true
  var@8 := true
  var@2 := discriminant(l)
  switch (move var@2) {
    0: isize => {
      var@8 := false
      hd := move (l as test1::List::Cons).0
      var@7 := false
      tl := move (l as test1::List::Cons).1
      var@5 := move hd
      var@6 := move deref_box(tl)
      (var@0).0 := move var@5
      (var@0).1 := move var@6
      var@9 := move alloc::alloc::box_free<test1::List<T>>(move tl)
      return
    }
    _ => {
      panic
    }
  }
}

fn test_split_list() {
  var@0 : ();
  l : test1::List<i32>;
  var@2 : std::boxed::Box<test1::List<i32>>;
  var@3 : test1::List<i32>;
  hd : i32;
  tl : test1::List<i32>;
  var@6 : (i32, test1::List<i32>);
  var@7 : test1::List<i32>;
  var@8 : bool;
  var@9 : bool;
  var@10 : i32;

  set_discriminant(var@3, 1)
  var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
  (l as test1::List::Cons).0 := 0: i32
  (l as test1::List::Cons).1 := move var@2
  set_discriminant(l, 0)
  var@7 := move l
  var@6 := move split_list<i32>(move var@7)
  hd := copy (var@6).0
  tl := move (var@6).1
  var@10 := copy hd
  var@9 := move var@10 == 0: i32
  var@8 := ¬ move var@9
  assert(¬move var@8)
drop(tl)
  return
}

fn get_elem<'a,T>(b : bool, x : &'a mut (T), y : &'a mut (T)) -> &'a mut (T) {
  var@0 : &'_ mut (T);
  b : bool;
  x : &'_ mut (T);
  y : &'_ mut (T);
  var@4 : bool;

  var@4 := copy b
  if (move var@4) {
    var@0 := &mut *(x)
  }
  else {
    var@0 := move y
  }
  return
}

fn get_elem_test() {
  var@0 : ();
  x : i32;
  y : i32;
  z : &'_ mut (i32);
  var@4 : &'_ mut (i32);
  var@5 : &'_ mut (i32);
  var@6 : &'_ mut (i32);
  var@7 : &'_ mut (i32);
  var@8 : i32;
  var@9 : (i32, bool);
  var@10 : bool;
  var@11 : bool;
  var@12 : i32;
  var@13 : bool;
  var@14 : bool;
  var@15 : i32;
  var@16 : bool;
  var@17 : bool;
  var@18 : i32;

  x := 0: i32
  y := 0: i32
  var@5 := &mut x
  var@4 := &two-phase *(var@5)
  var@7 := &mut y
  var@6 := &two-phase *(var@7)
  z := move get_elem<i32>(true, move var@4, move var@6)
  var@8 := copy *(z)
  *(z) := copy var@8 + 1: i32
  var@12 := copy *(z)
  var@11 := move var@12 == 1: i32
  var@10 := ¬ move var@11
  assert(¬move var@10)
  var@15 := copy x
  var@14 := move var@15 == 1: i32
  var@13 := ¬ move var@14
  assert(¬move var@13)
  var@18 := copy y
  var@17 := move var@18 == 0: i32
  var@16 := ¬ move var@17
  assert(¬move var@16)
  return
}

fn id_mut_mut<'a,'b,T>(x : &'a mut (&'b mut (T))) -> &'a mut (&'b mut (T)) {
  var@0 : &'_ mut (&'_ mut (T));
  x : &'_ mut (&'_ mut (T));
  var@2 : &'_ mut (&'_ mut (T));

  var@2 := &mut *(x)
  var@0 := &mut *(var@2)
  return
}

fn id_mut_pair<'a,T>(x : &'a mut ((&'a mut (T), u32))) -> &'a mut ((&'a mut (T), u32)) {
  var@0 : &'_ mut ((&'_ mut (T), u32));
  x : &'_ mut ((&'_ mut (T), u32));
  var@2 : &'_ mut ((&'_ mut (T), u32));

  var@2 := &mut *(x)
  var@0 := &mut *(var@2)
  return
}

fn id_mut_pair_test1() {
  var@0 : ();
  x : u32;
  px : &'_ mut (u32);
  p : (&'_ mut (u32), u32);
  var@4 : &'_ mut (u32);
  pp0 : &'_ mut ((&'_ mut (u32), u32));
  pp1 : &'_ mut ((&'_ mut (u32), u32));
  var@7 : &'_ mut ((&'_ mut (u32), u32));
  y : u32;
  var@9 : &'_ mut (u32);
  var@10 : &'_ mut (u32);

  x := 0: u32
  px := &mut x
  var@4 := move px
  (p).0 := move var@4
  (p).1 := 1: u32
  pp0 := &mut p
  var@7 := &two-phase *(pp0)
  pp1 := move id_mut_pair<u32>(move var@7)
  y := 2: u32
  var@10 := &mut y
  var@9 := &mut *(var@10)
  *((pp1).0) := move var@9
  *((pp1).1) := 3: u32
  return
}

fn id_mut_mut_pair<'a,T>(x : &'a mut (&'a mut ((&'a mut (T), u32)))) -> &'a mut (&'a mut ((&'a mut (T), u32))) {
  var@0 : &'_ mut (&'_ mut ((&'_ mut (T), u32)));
  x : &'_ mut (&'_ mut ((&'_ mut (T), u32)));
  var@2 : &'_ mut (&'_ mut ((&'_ mut (T), u32)));

  var@2 := &mut *(x)
  var@0 := &mut *(var@2)
  return
}

fn id_mut_mut_mut_same<'a,T>(x : &'a mut (&'a mut (&'a mut (u32)))) -> &'a mut (&'a mut (&'a mut (u32))) {
  var@0 : &'_ mut (&'_ mut (&'_ mut (u32)));
  x : &'_ mut (&'_ mut (&'_ mut (u32)));
  var@2 : &'_ mut (&'_ mut (&'_ mut (u32)));

  var@2 := &mut *(x)
  var@0 := &mut *(var@2)
  return
}

fn id_borrow1<'a,'b>(_x : &'a mut (&'b (u32)), _y : &'a (&'a mut (u32))) {
  var@0 : ();
  _x : &'_ mut (&'_ (u32));
  _y : &'_ (&'_ mut (u32));

  return
}

fn test_loop1(max : u32) -> u32 {
  s : u32;
  max : u32;
  i : u32;
  var@3 : bool;
  var@4 : u32;
  var@5 : u32;
  var@6 : u32;
  var@7 : (u32, bool);
  var@8 : (u32, bool);
  var@9 : (u32, bool);

  i := 0: u32
  s := 0: u32
  loop {
    var@4 := copy i
    var@5 := copy max
    var@3 := move var@4 < move var@5
    if (move var@3) {
      var@6 := copy i
      s := copy s + copy var@6
      i := copy i + 1: u32
      continue 0
    }
    else {
      break 0
    }
  }
  s := copy s * 2: u32
  return
}

fn test_loop2(max : u32) -> u32 {
  s : u32;
  max : u32;
  i : u32;
  var@3 : bool;
  var@4 : u32;
  var@5 : u32;
  var@6 : u32;
  var@7 : u32;
  var@8 : (u32, bool);
  var@9 : (u32, bool);

  i := 0: u32
  s := 0: u32
  loop {
    var@4 := copy i
    var@5 := copy max
    var@3 := move var@4 < move var@5
    if (move var@3) {
      var@6 := copy i
      switch (move var@6) {
        17: u32 => {
          break 0
        }
        _ => {
          var@7 := copy i
          s := copy s + copy var@7
          i := copy i + 1: u32
          continue 0
        }
      }
    }
    else {
      break 0
    }
  }
  return
}

fn test_loop3(max : u32) -> u32 {
  s : u32;
  max : u32;
  i : u32;
  j : u32;
  var@4 : bool;
  var@5 : u32;
  var@6 : u32;
  var@7 : bool;
  var@8 : u32;
  var@9 : u32;
  var@10 : u32;
  var@11 : u32;
  var@12 : u32;
  var@13 : (u32, bool);
  var@14 : u32;
  var@15 : (u32, bool);
  var@16 : (u32, bool);
  var@17 : u32;
  var@18 : (u32, bool);
  var@19 : (u32, bool);

  i := 0: u32
  j := 0: u32
  s := 0: u32
  loop {
    var@5 := copy i
    var@6 := copy max
    var@4 := move var@5 < move var@6
    if (move var@4) {
      loop {
        var@8 := copy j
        var@9 := copy max
        var@7 := move var@8 < move var@9
        if (move var@7) {
          var@11 := copy i
          var@12 := copy j
          var@10 := copy var@11 + copy var@12
          switch (move var@10) {
            17: u32 => {
              continue 0
            }
            _ => {
              nop
            }
          }
          var@14 := copy i
          s := copy s + copy var@14
          j := copy j + 1: u32
          continue 1
        }
        else {
          break 0
        }
      }
      j := 0: u32
      var@17 := copy i
      s := copy s + copy var@17
      i := copy i + 1: u32
      continue 0
    }
    else {
      break 0
    }
  }
  return
}

fn test_loop4(max : u32) -> u32 {
  s : u32;
  max : u32;
  i : u32;
  j : u32;
  var@4 : bool;
  var@5 : u32;
  var@6 : u32;
  var@7 : bool;
  var@8 : u32;
  var@9 : u32;
  var@10 : u32;
  var@11 : u32;
  var@12 : u32;
  var@13 : (u32, bool);
  var@14 : u32;
  var@15 : (u32, bool);
  var@16 : (u32, bool);
  var@17 : u32;
  var@18 : (u32, bool);
  var@19 : (u32, bool);

  i := 1: u32
  j := 0: u32
  s := 0: u32
  loop {
    var@5 := copy i
    var@6 := copy max
    var@4 := move var@5 < move var@6
    if (move var@4) {
      loop {
        var@8 := copy j
        var@9 := copy max
        var@7 := move var@8 < move var@9
        if (move var@7) {
          var@11 := copy i
          var@12 := copy j
          var@10 := copy var@11 + copy var@12
          switch (move var@10) {
            17: u32 => {
              continue 0
            }
            _ => {
              nop
            }
          }
          var@14 := copy i
          s := copy s + copy var@14
          j := copy j + 1: u32
          break 1
        }
        else {
          break 0
        }
      }
      j := 0: u32
      var@17 := copy i
      s := copy s + copy var@17
      i := copy i + 1: u32
      continue 0
    }
    else {
      break 0
    }
  }
  return
}

fn test_loop5(max : u32) -> u32 {
  s : u32;
  max : u32;
  i : u32;
  j : u32;
  var@4 : bool;
  var@5 : u32;
  var@6 : u32;
  var@7 : bool;
  var@8 : u32;
  var@9 : u32;
  var@10 : u32;
  var@11 : (u32, bool);
  var@12 : (u32, bool);
  var@13 : u32;
  var@14 : (u32, bool);
  var@15 : (u32, bool);

  i := 0: u32
  j := 0: u32
  s := 0: u32
  loop {
    var@5 := copy i
    var@6 := copy max
    var@4 := move var@5 < move var@6
    if (move var@4) {
      loop {
        var@8 := copy j
        var@9 := copy max
        var@7 := move var@8 < move var@9
        if (move var@7) {
          var@10 := copy j
          s := copy s + copy var@10
          j := copy j + 1: u32
          continue 0
        }
        else {
          break 0
        }
      }
      var@13 := copy i
      s := copy s + copy var@13
      i := copy i + 1: u32
      continue 0
    }
    else {
      break 0
    }
  }
  return
}

fn test_loop6(max : u32) -> u32 {
  s : u32;
  max : u32;
  i : u32;
  var@3 : bool;
  var@4 : u32;
  var@5 : u32;
  var@6 : bool;
  var@7 : u32;
  var@8 : u32;
  var@9 : (u32, bool);
  var@10 : (u32, bool);
  var@11 : (u32, bool);

  i := 0: u32
  s := 0: u32
  loop {
    var@4 := copy i
    var@5 := copy max
    var@3 := move var@4 < move var@5
    if (move var@3) {
      var@7 := copy i
      var@6 := move var@7 > 3: u32
      if (move var@6) {
        break 0
      }
      else {
        var@8 := copy i
        s := copy s + copy var@8
        i := copy i + 1: u32
        continue 0
      }
    }
    else {
      break 0
    }
  }
  s := copy s + 1: u32
  return
}

fn test_static(x : &'static (u32)) -> &'static (u32) {
  var@0 : &'_ (u32);
  x : &'_ (u32);

  var@0 := copy x
  return
}

fn test_char() -> char {
  var@0 : char;

  var@0 := a
  return
}

[Debug] test_unit_function: test2
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: x := 23: u32
y := 44: u32
z := 67: u32
var@5 := copy x
(p).x := move var@5
(p).y := 67: u32
(s as test1::Sum::Right).0 := true
set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: x := 23: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
23: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: y := 44: u32
z := 67: u32
var@5 := copy x
(p).x := move var@5
(p).y := 67: u32
(s as test1::Sum::Right).0 := true
set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: y := 44: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
44: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: z := 67: u32
var@5 := copy x
(p).x := move var@5
(p).y := 67: u32
(s as test1::Sum::Right).0 := true
set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: z := 67: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> ⊥ : u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
67: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: var@5 := copy x
(p).x := move var@5
(p).y := 67: u32
(s as test1::Sum::Right).0 := true
set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: var@5 := copy x

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
copy x

[Debug] Value to copy:
23: u32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> 23: u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (p).x := move var@5
(p).y := 67: u32
(s as test1::Sum::Right).0 := true
set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> 23: u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (p).x := move var@5

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> ⊥ : test1::Pair<u32, u32> ;
  var@5 -> 23: u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
move var@5

[Debug] Value to move:
23: u32
[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjAdt (0, None)), 0))
ty: (Types.Adt ((Types.AdtId 0), [],
   [(Types.Integer Types.U32); (Types.Integer Types.U32)]))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = ⊥ : u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (p).y := 67: u32
(s as test1::Sum::Right).0 := true
set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = ⊥ : u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (p).y := 67: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = ⊥ : u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
67: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (s as test1::Sum::Right).0 := true
set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (s as test1::Sum::Right).0 := true

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> ⊥ : test1::Sum<u32, bool> ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
true

[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjAdt (6, (Some 1))), 0))
ty: (Types.Adt ((Types.AdtId 6), [], [(Types.Integer Types.U32); Types.Bool]))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(s, 1)
(o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(s, 1)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (o as test1::One::One).0 := 3: u64
set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: (o as test1::One::One).0 := 3: u64

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> ⊥ : test1::One<u64> ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}


- op:
3: u64

[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjAdt (2, (Some 0))), 0))
ty: (Types.Adt ((Types.AdtId 2), [], [(Types.Integer Types.U64)]))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> test1::One::One { 0 = 3: u64; } ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(o, 0)
set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> test1::One::One { 0 = 3: u64; } ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(o, 0)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> test1::One::One { 0 = 3: u64; } ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(e0, 0)
set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> test1::One::One { 0 = 3: u64; } ;
  e0 -> ⊥ : test1::EmptyEnum ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(e0, 0)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> test1::One::One { 0 = 3: u64; } ;
  e0 -> test1::EmptyEnum::Empty ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(enum0, 0)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> test1::One::One { 0 = 3: u64; } ;
  e0 -> test1::EmptyEnum::Empty ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> ⊥ : test1::Enum ;
}

About to evaluate statement: set_discriminant(enum0, 0)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 23: u32 ;
  y -> 44: u32 ;
  z -> 67: u32 ;
  p -> test1::Pair { x = 23: u32; y = 67: u32; } ;
  var@5 -> ⊥ : u32 ;
  s -> test1::Sum::Right { 0 = true; } ;
  o -> test1::One::One { 0 = 3: u64; } ;
  e0 -> test1::EmptyEnum::Empty ;
  e1 -> ⊥ : test1::EmptyEnum ;
  enum0 -> test1::Enum::Variant1 ;
}

About to evaluate statement: return

[Debug] test_unit_function: test3
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: x := move get_max(4: u32, 3: u32)
y := move get_max(10: u32, 11: u32)
var@4 := copy x
var@5 := copy y
z := copy var@4 + copy var@5
var@9 := copy z
var@8 := move var@9 == 15: u32
var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: x := move get_max(4: u32, 3: u32)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
4: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
3: u32

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@4 := copy x
var@5 := copy y
var@3 := move var@4 >= move var@5
if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@4 := copy x

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
copy x

[Debug] Value to copy:
4: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 4: u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@5 := copy y
var@3 := move var@4 >= move var@5
if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 4: u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@5 := copy y

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 4: u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
copy y

[Debug] Value to copy:
3: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 4: u32 ;
  var@5 -> 3: u32 ;
}

About to evaluate statement: var@3 := move var@4 >= move var@5
if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 4: u32 ;
  var@5 -> 3: u32 ;
}

About to evaluate statement: var@3 := move var@4 >= move var@5

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 4: u32 ;
  var@5 -> 3: u32 ;
}


- op:
move var@4

[Debug] Value to move:
4: u32
[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> 3: u32 ;
}


- op:
move var@5

[Debug] Value to move:
3: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> true ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> true ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> true ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
move var@3

[Debug] Value to move:
true
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@0 := copy x

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
copy x

[Debug] Value to copy:
4: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 4: u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: return

[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 4: u32 ;
  x -> 4: u32 ;
  y -> 3: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

[Debug] ctx_pop_frame: locals to drop: [5,4,3,2,1]
[Debug] drop_value: place: var@5
[Debug] drop_value: place: var@4
[Debug] drop_value: place: var@3
[Debug] drop_value: place: y
[Debug] drop_value: place: x
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 4: u32 ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 4: u32 ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
move var@0

[Debug] Value to move:
4: u32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: y := move get_max(10: u32, 11: u32)
var@4 := copy x
var@5 := copy y
z := copy var@4 + copy var@5
var@9 := copy z
var@8 := move var@9 == 15: u32
var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: y := move get_max(10: u32, 11: u32)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
10: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
11: u32

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@4 := copy x
var@5 := copy y
var@3 := move var@4 >= move var@5
if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@4 := copy x

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
copy x

[Debug] Value to copy:
10: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 10: u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@5 := copy y
var@3 := move var@4 >= move var@5
if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 10: u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@5 := copy y

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 10: u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
copy y

[Debug] Value to copy:
11: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 10: u32 ;
  var@5 -> 11: u32 ;
}

About to evaluate statement: var@3 := move var@4 >= move var@5
if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 10: u32 ;
  var@5 -> 11: u32 ;
}

About to evaluate statement: var@3 := move var@4 >= move var@5

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> 10: u32 ;
  var@5 -> 11: u32 ;
}


- op:
move var@4

[Debug] Value to move:
10: u32
[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> 11: u32 ;
}


- op:
move var@5

[Debug] Value to move:
11: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> false ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> false ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: if (move var@3) {
  var@0 := copy x
}
else {
  var@0 := copy y
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> false ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
move var@3

[Debug] Value to move:
false
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: var@0 := copy y

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
copy y

[Debug] Value to copy:
11: u32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 11: u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

About to evaluate statement: return

[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 11: u32 ;
  x -> 10: u32 ;
  y -> 11: u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

[Debug] ctx_pop_frame: locals to drop: [5,4,3,2,1]
[Debug] drop_value: place: var@5
[Debug] drop_value: place: var@4
[Debug] drop_value: place: var@3
[Debug] drop_value: place: y
[Debug] drop_value: place: x
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 11: u32 ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> ⊥ : u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

# Frame 1:
{
  var@0 -> 11: u32 ;
  x -> ⊥ : u32 ;
  y -> ⊥ : u32 ;
  var@3 -> ⊥ : bool ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
move var@0

[Debug] Value to move:
11: u32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@4 := copy x
var@5 := copy y
z := copy var@4 + copy var@5
var@9 := copy z
var@8 := move var@9 == 15: u32
var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@4 := copy x

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
copy x

[Debug] Value to copy:
4: u32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> 4: u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@5 := copy y
z := copy var@4 + copy var@5
var@9 := copy z
var@8 := move var@9 == 15: u32
var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> 4: u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@5 := copy y

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> 4: u32 ;
  var@5 -> ⊥ : u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
copy y

[Debug] Value to copy:
11: u32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: z := copy var@4 + copy var@5
var@9 := copy z
var@8 := move var@9 == 15: u32
var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: z := copy var@4 + copy var@5

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
copy var@4

[Debug] Value to copy:
4: u32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> ⊥ : u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
copy var@5

[Debug] Value to copy:
11: u32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@9 := copy z
var@8 := move var@9 == 15: u32
var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@9 := copy z

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
copy z

[Debug] Value to copy:
15: u32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> 15: u32 ;
}

About to evaluate statement: var@8 := move var@9 == 15: u32
var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> 15: u32 ;
}

About to evaluate statement: var@8 := move var@9 == 15: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> 15: u32 ;
}


- op:
move var@9

[Debug] Value to move:
15: u32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
15: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> true ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@7 := ¬ move var@8
assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> true ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: var@7 := ¬ move var@8

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> true ;
  var@9 -> ⊥ : u32 ;
}


- op:
move var@8

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> false ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: assert(¬move var@7)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> false ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: assert(¬move var@7)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> false ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}


- op:
move var@7

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 4: u32 ;
  y -> 11: u32 ;
  z -> 15: u32 ;
  var@4 -> 4: u32 ;
  var@5 -> 11: u32 ;
  var@6 -> ⊥ : (u32, bool) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : u32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: test_neg1
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
}

About to evaluate statement: x := 3: i32
y := -3: i32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
}

About to evaluate statement: x := 3: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
}


- op:
3: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 3: i32 ;
  y -> ⊥ : i32 ;
}

About to evaluate statement: y := -3: i32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 3: i32 ;
  y -> ⊥ : i32 ;
}

About to evaluate statement: y := -3: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 3: i32 ;
  y -> ⊥ : i32 ;
}


- op:
-3: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 3: i32 ;
  y -> -3: i32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: refs_test1
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32
px := &mut x
ppx := &mut px
*(*(ppx)) := 1: i32
var@6 := copy x
var@5 := move var@6 == 1: i32
var@4 := ¬ move var@5
assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: px := &mut x
ppx := &mut px
*(*(ppx)) := 1: i32
var@6 := copy x
var@5 := move var@6 == 1: i32
var@4 := ¬ move var@5
assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: px := &mut x

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> &mut@0 (0: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: ppx := &mut px
*(*(ppx)) := 1: i32
var@6 := copy x
var@5 := move var@6 == 1: i32
var@4 := ¬ move var@5
assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> &mut@0 (0: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: ppx := &mut px

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⌊mut@1⌋ ;
  ppx -> &mut@1 (&mut@0 (0: i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: *(*(ppx)) := 1: i32
var@6 := copy x
var@5 := move var@6 == 1: i32
var@4 := ¬ move var@5
assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⌊mut@1⌋ ;
  ppx -> &mut@1 (&mut@0 (0: i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: *(*(ppx)) := 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⌊mut@1⌋ ;
  ppx -> &mut@1 (&mut@0 (0: i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⌊mut@1⌋ ;
  ppx -> &mut@1 (&mut@0 (1: i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := copy x
var@5 := move var@6 == 1: i32
var@4 := ¬ move var@5
assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⌊mut@1⌋ ;
  ppx -> &mut@1 (&mut@0 (1: i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := copy x

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⌊mut@1⌋ ;
  ppx -> &mut@1 (&mut@0 (1: i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}


- op:
copy x

[Debug] Value to copy:
1: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> 1: i32 ;
}

About to evaluate statement: var@5 := move var@6 == 1: i32
var@4 := ¬ move var@5
assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> 1: i32 ;
}

About to evaluate statement: var@5 := move var@6 == 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> 1: i32 ;
}


- op:
move var@6

[Debug] Value to move:
1: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> true ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: var@4 := ¬ move var@5
assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> true ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: var@4 := ¬ move var@5

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> true ;
  var@6 -> ⊥ : i32 ;
}


- op:
move var@5

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> false ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@4)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> false ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@4)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> false ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}


- op:
move var@4

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : i32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: refs_test2
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32
y := 1: i32
px := &mut x
py := &mut y
ppx := &mut px
var@6 := &mut *(py)
*(ppx) := move var@6
*(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: y := 1: i32
px := &mut x
py := &mut y
ppx := &mut px
var@6 := &mut *(py)
*(ppx) := move var@6
*(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: y := 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⊥ : i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: px := &mut x
py := &mut y
ppx := &mut px
var@6 := &mut *(py)
*(ppx) := move var@6
*(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 1: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: px := &mut x

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> 1: i32 ;
  px -> &mut@0 (0: i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: py := &mut y
ppx := &mut px
var@6 := &mut *(py)
*(ppx) := move var@6
*(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> 1: i32 ;
  px -> &mut@0 (0: i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: py := &mut y

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@0 (0: i32) ;
  py -> &mut@1 (1: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: ppx := &mut px
var@6 := &mut *(py)
*(ppx) := move var@6
*(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@0 (0: i32) ;
  py -> &mut@1 (1: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: ppx := &mut px

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (1: i32) ;
  ppx -> &mut@2 (&mut@0 (0: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := &mut *(py)
*(ppx) := move var@6
*(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (1: i32) ;
  ppx -> &mut@2 (&mut@0 (0: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := &mut *(py)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@0 (0: i32)) ;
  var@6 -> &mut@3 (1: i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: *(ppx) := move var@6
*(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@0 (0: i32)) ;
  var@6 -> &mut@3 (1: i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: *(ppx) := move var@6

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@0 (0: i32)) ;
  var@6 -> &mut@3 (1: i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@6

[Debug] Value to move:
&mut@3 (1: i32)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@3 (1: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: *(*(ppx)) := 2: i32
var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@3 (1: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: *(*(ppx)) := 2: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@3 (1: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
2: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@3 (2: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@9 := copy *(px)
var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@3 (2: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@9 := copy *(px)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⌊mut@2⌋ ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> &mut@2 (&mut@3 (2: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy *(px)

[Debug] Value to copy:
2: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> 2: i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := move var@9 == 2: i32
var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> 2: i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := move var@9 == 2: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> 2: i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@9

[Debug] Value to move:
2: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
2: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> true ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := ¬ move var@8
assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> true ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := ¬ move var@8

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> true ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@8

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> false ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@7)
var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> false ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@7)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> false ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@7

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@12 := copy x
var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@12 := copy x

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy x

[Debug] Value to copy:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> 0: i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@11 := move var@12 == 0: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> 0: i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@11 := move var@12 == 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> 0: i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@12

[Debug] Value to move:
0: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> true ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> true ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@10 := ¬ move var@11

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> true ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@11

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> false ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@10)
var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> false ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@10)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> false ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@10

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@15 := copy *(py)
var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@15 := copy *(py)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> &mut@3 (2: i32) ;
  py -> &mut@1 (⌊mut@3⌋) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy *(py)

[Debug] Value to copy:
2: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> 2: i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@14 := move var@15 == 2: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> 2: i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@14 := move var@15 == 2: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> 2: i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@15

[Debug] Value to move:
2: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
2: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> true ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> true ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@13 := ¬ move var@14

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> true ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@14

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> false ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> false ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@13)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> false ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@13

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@18 := copy y
var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@18 := copy y

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⌊mut@1⌋ ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> &mut@1 (2: i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy y

[Debug] Value to copy:
2: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> 2: i32 ;
}

About to evaluate statement: var@17 := move var@18 == 2: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> 2: i32 ;
}

About to evaluate statement: var@17 := move var@18 == 2: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> 2: i32 ;
}


- op:
move var@18

[Debug] Value to move:
2: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
2: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> true ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> true ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@16 := ¬ move var@17

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> true ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@17

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> false ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> false ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@16)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> false ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@16

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 2: i32 ;
  px -> ⊥ : &'_ mut (i32) ;
  py -> ⊥ : &'_ mut (i32) ;
  ppx -> ⊥ : &'_ mut (&'_ mut (i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : i32 ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: test_list1
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: set_discriminant(var@3, 1)
var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
(l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: set_discriminant(var@3, 1)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
}

About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
(l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
}

About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)

[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxNew
- type_params: [test1::List<i32>]
- args: [move var@3]
- dest: var@2
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
}


- op:
move var@3

[Debug] Value to move:
test1::List::Nil
[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

# Frame 1:
{
  @return -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@1 -> test1::List::Nil ;
}


- op:
move var@1

[Debug] Value to move:
test1::List::Nil
[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}

[Debug] ctx_pop_frame: locals to drop: [1]
[Debug] drop_value: place: var@1
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}


- op:
move @return

[Debug] Value to move:
@Box(test1::List::Nil)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: (l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: (l as test1::List::Cons).0 := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
}


- op:
0: i32

[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjAdt (1, (Some 0))), 0))
ty: (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)]))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: (l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: (l as test1::List::Cons).1 := move var@2

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
}


- op:
move var@2

[Debug] Value to move:
@Box(test1::List::Nil)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: set_discriminant(l, 0)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: set_discriminant(l, 0)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: drop(l)

[Debug] drop_value: place: l
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
}

About to evaluate statement: return

[Debug] test_unit_function: test_box1
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: b := move alloc::boxed::Box<i32>::new(0: i32)
var@3 := &two-phase b
x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3)
*(x) := 1: i32
var@5 := &b
x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)
var@8 := copy *(x)
var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: b := move alloc::boxed::Box<i32>::new(0: i32)

[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxNew
- type_params: [i32]
- args: [0: i32]
- dest: b
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> ⊥ : std::boxed::Box<i32> ;
  var@1 -> 0: i32 ;
}


- op:
move var@1

[Debug] Value to move:
0: i32
[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> @Box(0: i32) ;
  var@1 -> ⊥ : i32 ;
}

[Debug] ctx_pop_frame: locals to drop: [1]
[Debug] drop_value: place: var@1
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> @Box(0: i32) ;
  var@1 -> ⊥ : i32 ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> @Box(0: i32) ;
  var@1 -> ⊥ : i32 ;
}


- op:
move @return

[Debug] Value to move:
@Box(0: i32)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(0: i32) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@3 := &two-phase b
x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3)
*(x) := 1: i32
var@5 := &b
x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)
var@8 := copy *(x)
var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(0: i32) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@3 := &two-phase b

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({0}, @Box(0: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⌊inactivated_mut@0⌋ ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3)
*(x) := 1: i32
var@5 := &b
x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)
var@8 := copy *(x)
var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({0}, @Box(0: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⌊inactivated_mut@0⌋ ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3)

[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxDerefMut
- type_params: [i32]
- args: [move var@3]
- dest: x
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({0}, @Box(0: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⌊inactivated_mut@0⌋ ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}


- op:
move var@3

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Adt
     { Values.variant_id = <opaque>;
       field_values =
       [{ Values.value =
          (Values.Concrete
             (Values.Scalar { Values.value = 0; int_ty = Types.I32 }));
          ty = (Types.Integer Types.I32) }
         ]
       });
  ty =
  (Types.Adt ((Types.Assumed Types.Box), [], [(Types.Integer Types.I32)])) }
[Debug] Value to move:
&mut@0 (@Box(0: i32))
[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⌊mut@0⌋ ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> &mut@1 (0: i32) ;
  var@1 -> &mut@0 (@Box(⌊mut@1⌋)) ;
}

[Debug] ctx_pop_frame: locals to drop: [1]
[Debug] drop_value: place: var@1
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(⌊mut@1⌋) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> &mut@1 (0: i32) ;
  var@1 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(⌊mut@1⌋) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> &mut@1 (0: i32) ;
  var@1 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
}


- op:
move @return

[Debug] Value to move:
&mut@1 (0: i32)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(⌊mut@1⌋) ;
  x -> &mut@1 (0: i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: *(x) := 1: i32
var@5 := &b
x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)
var@8 := copy *(x)
var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(⌊mut@1⌋) ;
  x -> &mut@1 (0: i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: *(x) := 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(⌊mut@1⌋) ;
  x -> &mut@1 (0: i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(⌊mut@1⌋) ;
  x -> &mut@1 (1: i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@5 := &b
x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)
var@8 := copy *(x)
var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(⌊mut@1⌋) ;
  x -> &mut@1 (1: i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@5 := &b

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, @Box(1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⌊shared@2⌋ ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)
var@8 := copy *(x)
var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, @Box(1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⌊shared@2⌋ ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: x := move core::ops::deref::Deref<Box<i32>>::deref(move var@5)

[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxDeref
- type_params: [i32]
- args: [move var@5]
- dest: x
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, @Box(1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⌊shared@2⌋ ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}


- op:
move var@5

[Debug] Value to move:
⌊shared@2⌋
[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, @Box(@shared_loan({3}, 1: i32))) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> ⌊shared@3⌋ ;
  var@1 -> ⌊shared@2⌋ ;
}

[Debug] ctx_pop_frame: locals to drop: [1]
[Debug] drop_value: place: var@1
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> ⌊shared@3⌋ ;
  var@1 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> ⌊shared@3⌋ ;
  var@1 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
}


- op:
move @return

[Debug] Value to move:
⌊shared@3⌋
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := copy *(x)
var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := copy *(x)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}


- op:
copy *(x)

[Debug] Value to copy:
1: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> 1: i32 ;
}

About to evaluate statement: var@7 := move var@8 == 1: i32
var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> 1: i32 ;
}

About to evaluate statement: var@7 := move var@8 == 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> 1: i32 ;
}


- op:
move var@8

[Debug] Value to move:
1: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> true ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := ¬ move var@7
assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> true ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := ¬ move var@7

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> true ;
  var@8 -> ⊥ : i32 ;
}


- op:
move var@7

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> false ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@6)
drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> false ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@6)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> false ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}


- op:
move var@6

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: drop(b)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @Box(@shared_loan({3}, 1: i32)) ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⌊shared@3⌋ ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: drop(b)

[Debug] drop_value: place: b
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⊥ : std::boxed::Box<i32> ;
  x -> ⊥ : &'_ mut (i32) ;
  var@3 -> ⊥ : &'_ mut (std::boxed::Box<i32>) ;
  x -> ⊥ : &'_ (i32) ;
  var@5 -> ⊥ : &'_ (std::boxed::Box<i32>) ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: test_copy_int
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  px -> ⊥ : &'_ (i32) ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32
px := &x
var@4 := copy x
y := move copy_int(move var@4)
var@7 := copy *(px)
var@8 := copy y
var@6 := move var@7 == move var@8
var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  px -> ⊥ : &'_ (i32) ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  px -> ⊥ : &'_ (i32) ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  px -> ⊥ : &'_ (i32) ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: px := &x
var@4 := copy x
y := move copy_int(move var@4)
var@7 := copy *(px)
var@8 := copy y
var@6 := move var@7 == move var@8
var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  px -> ⊥ : &'_ (i32) ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: px := &x

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@4 := copy x
y := move copy_int(move var@4)
var@7 := copy *(px)
var@8 := copy y
var@6 := move var@7 == move var@8
var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@4 := copy x

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}


- op:
copy x

[Debug] Value to copy:
@shared_loan({0}, 0: i32)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> 0: i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: y := move copy_int(move var@4)
var@7 := copy *(px)
var@8 := copy y
var@6 := move var@7 == move var@8
var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> 0: i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: y := move copy_int(move var@4)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> 0: i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}


- op:
move var@4

[Debug] Value to move:
0: i32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : i32 ;
  x -> 0: i32 ;
}

About to evaluate statement: var@0 := copy x
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : i32 ;
  x -> 0: i32 ;
}

About to evaluate statement: var@0 := copy x

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : i32 ;
  x -> 0: i32 ;
}


- op:
copy x

[Debug] Value to copy:
0: i32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> 0: i32 ;
  x -> 0: i32 ;
}

About to evaluate statement: return

[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> 0: i32 ;
  x -> 0: i32 ;
}

[Debug] ctx_pop_frame: locals to drop: [1]
[Debug] drop_value: place: x
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> 0: i32 ;
  x -> ⊥ : i32 ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> ⊥ : i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> 0: i32 ;
  x -> ⊥ : i32 ;
}


- op:
move var@0

[Debug] Value to move:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := copy *(px)
var@8 := copy y
var@6 := move var@7 == move var@8
var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := copy *(px)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}


- op:
copy *(px)

[Debug] Value to copy:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> 0: i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := copy y
var@6 := move var@7 == move var@8
var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> 0: i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := copy y

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> 0: i32 ;
  var@8 -> ⊥ : i32 ;
}


- op:
copy y

[Debug] Value to copy:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> 0: i32 ;
  var@8 -> 0: i32 ;
}

About to evaluate statement: var@6 := move var@7 == move var@8
var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> 0: i32 ;
  var@8 -> 0: i32 ;
}

About to evaluate statement: var@6 := move var@7 == move var@8

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> 0: i32 ;
  var@8 -> 0: i32 ;
}


- op:
move var@7

[Debug] Value to move:
0: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> 0: i32 ;
}


- op:
move var@8

[Debug] Value to move:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> true ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@5 := ¬ move var@6
assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> true ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: var@5 := ¬ move var@6

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> true ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}


- op:
move var@6

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> false ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@5)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> false ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@5)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> false ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}


- op:
move var@5

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> 0: i32 ;
  var@4 -> ⊥ : i32 ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : bool ;
  var@7 -> ⊥ : i32 ;
  var@8 -> ⊥ : i32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: test_is_cons
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: set_discriminant(var@3, 1)
var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
(l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := &l
var@6 := copy var@7
var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: set_discriminant(var@3, 1)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
(l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := &l
var@6 := copy var@7
var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)

[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxNew
- type_params: [test1::List<i32>]
- args: [move var@3]
- dest: var@2
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}


- op:
move var@3

[Debug] Value to move:
test1::List::Nil
[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

# Frame 1:
{
  @return -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@1 -> test1::List::Nil ;
}


- op:
move var@1

[Debug] Value to move:
test1::List::Nil
[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}

[Debug] ctx_pop_frame: locals to drop: [1]
[Debug] drop_value: place: var@1
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}


- op:
move @return

[Debug] Value to move:
@Box(test1::List::Nil)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: (l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := &l
var@6 := copy var@7
var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: (l as test1::List::Cons).0 := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}


- op:
0: i32

[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjAdt (1, (Some 0))), 0))
ty: (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)]))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: (l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := &l
var@6 := copy var@7
var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: (l as test1::List::Cons).1 := move var@2

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}


- op:
move var@2

[Debug] Value to move:
@Box(test1::List::Nil)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: set_discriminant(l, 0)
var@7 := &l
var@6 := copy var@7
var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: set_discriminant(l, 0)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: var@7 := &l
var@6 := copy var@7
var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: var@7 := &l

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: var@6 := copy var@7
var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: var@6 := copy var@7

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}


- op:
copy var@7

[Debug] Value to copy:
⌊shared@0⌋
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⌊shared@1⌋ ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: var@5 := move is_cons<i32>(move var@6)
var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⌊shared@1⌋ ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: var@5 := move is_cons<i32>(move var@6)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⌊shared@1⌋ ;
  var@7 -> ⌊shared@0⌋ ;
}


- op:
move var@6

[Debug] Value to move:
⌊shared@1⌋
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@1⌋ ;
  var@2 -> ⊥ : isize ;
}

About to evaluate statement: var@2 := discriminant(*(l))
switch (move var@2) {
  0: isize => {
    var@0 := true
  }
  1: isize => {
    var@0 := false
  }
  _ => {
    panic
  }
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@1⌋ ;
  var@2 -> ⊥ : isize ;
}

About to evaluate statement: var@2 := discriminant(*(l))

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@1⌋ ;
  var@2 -> 0: isize ;
}

About to evaluate statement: switch (move var@2) {
  0: isize => {
    var@0 := true
  }
  1: isize => {
    var@0 := false
  }
  _ => {
    panic
  }
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@1⌋ ;
  var@2 -> 0: isize ;
}

About to evaluate statement: switch (move var@2) {
  0: isize => {
    var@0 := true
  }
  1: isize => {
    var@0 := false
  }
  _ => {
    panic
  }
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@1⌋ ;
  var@2 -> 0: isize ;
}


- op:
move var@2

[Debug] Value to move:
0: isize
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@1⌋ ;
  var@2 -> ⊥ : isize ;
}

About to evaluate statement: var@0 := true

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@1⌋ ;
  var@2 -> ⊥ : isize ;
}


- op:
true

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> true ;
  l -> ⌊shared@1⌋ ;
  var@2 -> ⊥ : isize ;
}

About to evaluate statement: return

[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> true ;
  l -> ⌊shared@1⌋ ;
  var@2 -> ⊥ : isize ;
}

[Debug] ctx_pop_frame: locals to drop: [2,1]
[Debug] drop_value: place: var@2
[Debug] drop_value: place: l
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> true ;
  l -> ⊥ : &'_ (test1::List<i32>) ;
  var@2 -> ⊥ : isize ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

# Frame 1:
{
  var@0 -> true ;
  l -> ⊥ : &'_ (test1::List<i32>) ;
  var@2 -> ⊥ : isize ;
}


- op:
move var@0

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> true ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: var@4 := ¬ move var@5
assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> true ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: var@4 := ¬ move var@5

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> true ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}


- op:
move var@5

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> false ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: assert(¬move var@4)
drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> false ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: assert(¬move var@4)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> false ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}


- op:
move var@4

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: drop(l)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
}

About to evaluate statement: drop(l)

[Debug] drop_value: place: l
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⊥ : &'_ (test1::List<i32>) ;
}

About to evaluate statement: return

[Debug] test_unit_function: test_split_list
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: set_discriminant(var@3, 1)
var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
(l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := move l
var@6 := move split_list<i32>(move var@7)
hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: set_discriminant(var@3, 1)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)
(l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := move l
var@6 := move split_list<i32>(move var@7)
hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@2 := move alloc::boxed::Box<test1::List<i32>>::new(move var@3)

[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxNew
- type_params: [test1::List<i32>]
- args: [move var@3]
- dest: var@2
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> test1::List::Nil ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@3

[Debug] Value to move:
test1::List::Nil
[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@1 -> test1::List::Nil ;
}


- op:
move var@1

[Debug] Value to move:
test1::List::Nil
[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}

[Debug] ctx_pop_frame: locals to drop: [1]
[Debug] drop_value: place: var@1
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  @return -> @Box(test1::List::Nil) ;
  var@1 -> ⊥ : test1::List<i32> ;
}


- op:
move @return

[Debug] Value to move:
@Box(test1::List::Nil)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: (l as test1::List::Cons).0 := 0: i32
(l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := move l
var@6 := move split_list<i32>(move var@7)
hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: (l as test1::List::Cons).0 := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjAdt (1, (Some 0))), 0))
ty: (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)]))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: (l as test1::List::Cons).1 := move var@2
set_discriminant(l, 0)
var@7 := move l
var@6 := move split_list<i32>(move var@7)
hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: (l as test1::List::Cons).1 := move var@2

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@2

[Debug] Value to move:
@Box(test1::List::Nil)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: set_discriminant(l, 0)
var@7 := move l
var@6 := move split_list<i32>(move var@7)
hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: set_discriminant(l, 0)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := move l
var@6 := move split_list<i32>(move var@7)
hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := move l

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move l

[Debug] Value to move:
test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := move split_list<i32>(move var@7)
hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := move split_list<i32>(move var@7)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@7

[Debug] Value to move:
test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); }
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@8 := false
var@7 := false
var@7 := true
var@8 := true
var@2 := discriminant(l)
switch (move var@2) {
  0: isize => {
    var@8 := false
    hd := move (l as test1::List::Cons).0
    var@7 := false
    tl := move (l as test1::List::Cons).1
    var@5 := move hd
    var@6 := move deref_box(tl)
    (var@0).0 := move var@5
    (var@0).1 := move var@6
    var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
    return
  }
  _ => {
    panic
  }
}

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@8 := false

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
false

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@7 := false
var@7 := true
var@8 := true
var@2 := discriminant(l)
switch (move var@2) {
  0: isize => {
    var@8 := false
    hd := move (l as test1::List::Cons).0
    var@7 := false
    tl := move (l as test1::List::Cons).1
    var@5 := move hd
    var@6 := move deref_box(tl)
    (var@0).0 := move var@5
    (var@0).1 := move var@6
    var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
    return
  }
  _ => {
    panic
  }
}

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@7 := false

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
false

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@7 := true
var@8 := true
var@2 := discriminant(l)
switch (move var@2) {
  0: isize => {
    var@8 := false
    hd := move (l as test1::List::Cons).0
    var@7 := false
    tl := move (l as test1::List::Cons).1
    var@5 := move hd
    var@6 := move deref_box(tl)
    (var@0).0 := move var@5
    (var@0).1 := move var@6
    var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
    return
  }
  _ => {
    panic
  }
}

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@7 := true

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
true

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@8 := true
var@2 := discriminant(l)
switch (move var@2) {
  0: isize => {
    var@8 := false
    hd := move (l as test1::List::Cons).0
    var@7 := false
    tl := move (l as test1::List::Cons).1
    var@5 := move hd
    var@6 := move deref_box(tl)
    (var@0).0 := move var@5
    (var@0).1 := move var@6
    var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
    return
  }
  _ => {
    panic
  }
}

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@8 := true

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
true

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@2 := discriminant(l)
switch (move var@2) {
  0: isize => {
    var@8 := false
    hd := move (l as test1::List::Cons).0
    var@7 := false
    tl := move (l as test1::List::Cons).1
    var@5 := move hd
    var@6 := move deref_box(tl)
    (var@0).0 := move var@5
    (var@0).1 := move var@6
    var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
    return
  }
  _ => {
    panic
  }
}

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@2 := discriminant(l)

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> 0: isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: switch (move var@2) {
  0: isize => {
    var@8 := false
    hd := move (l as test1::List::Cons).0
    var@7 := false
    tl := move (l as test1::List::Cons).1
    var@5 := move hd
    var@6 := move deref_box(tl)
    (var@0).0 := move var@5
    (var@0).1 := move var@6
    var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
    return
  }
  _ => {
    panic
  }
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> 0: isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@2

[Debug] Value to move:
0: isize
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@8 := false
hd := move (l as test1::List::Cons).0
var@7 := false
tl := move (l as test1::List::Cons).1
var@5 := move hd
var@6 := move deref_box(tl)
(var@0).0 := move var@5
(var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@8 := false

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
false

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: hd := move (l as test1::List::Cons).0
var@7 := false
tl := move (l as test1::List::Cons).1
var@5 := move hd
var@6 := move deref_box(tl)
(var@0).0 := move var@5
(var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: hd := move (l as test1::List::Cons).0

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move (l as test1::List::Cons).0

[Debug] Value to move:
0: i32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@7 := false
tl := move (l as test1::List::Cons).1
var@5 := move hd
var@6 := move deref_box(tl)
(var@0).0 := move var@5
(var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@7 := false

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
false

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: tl := move (l as test1::List::Cons).1
var@5 := move hd
var@6 := move deref_box(tl)
(var@0).0 := move var@5
(var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: tl := move (l as test1::List::Cons).1

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = @Box(test1::List::Nil); } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move (l as test1::List::Cons).1

[Debug] Value to move:
@Box(test1::List::Nil)
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> @Box(test1::List::Nil) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@5 := move hd
var@6 := move deref_box(tl)
(var@0).0 := move var@5
(var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> @Box(test1::List::Nil) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@5 := move hd

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> 0: i32 ;
  tl -> @Box(test1::List::Nil) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move hd

[Debug] Value to move:
0: i32
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(test1::List::Nil) ;
  var@5 -> 0: i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@6 := move deref_box(tl)
(var@0).0 := move var@5
(var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(test1::List::Nil) ;
  var@5 -> 0: i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@6 := move deref_box(tl)

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(test1::List::Nil) ;
  var@5 -> 0: i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move deref_box(tl)

[Debug] Value to move:
test1::List::Nil
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> 0: i32 ;
  var@6 -> test1::List::Nil ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: (var@0).0 := move var@5
(var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> 0: i32 ;
  var@6 -> test1::List::Nil ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: (var@0).0 := move var@5

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : (i32, test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> 0: i32 ;
  var@6 -> test1::List::Nil ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@5

[Debug] Value to move:
0: i32
[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjTuple 2), 0))
ty: (Types.Adt (Types.Tuple, [],
   [(Types.Integer Types.I32);
     (Types.Adt ((Types.AdtId 1), [], [(Types.Integer Types.I32)]))]
   ))
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, ⊥ : test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> test1::List::Nil ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: (var@0).1 := move var@6
var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, ⊥ : test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> test1::List::Nil ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: (var@0).1 := move var@6

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, ⊥ : test1::List<i32>) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> test1::List::Nil ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@6

[Debug] Value to move:
test1::List::Nil
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, test1::List::Nil) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, test1::List::Nil) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> @Box(⊥ : test1::List<i32>) ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)

[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxFree
- type_params: [test1::List<i32>]
- args: [move tl]
- dest: var@9
[Debug] drop_value: place: tl
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, test1::List::Nil) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> () ;
  var@10 -> ⊥ : isize ;
}

About to evaluate statement: return

[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, test1::List::Nil) ;
  l -> test1::List::Cons { 0 = ⊥ : i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> () ;
  var@10 -> ⊥ : isize ;
}

[Debug] ctx_pop_frame: locals to drop: [10,9,8,7,6,5,4,3,2,1]
[Debug] drop_value: place: var@10
[Debug] drop_value: place: var@9
[Debug] drop_value: place: var@8
[Debug] drop_value: place: var@7
[Debug] drop_value: place: var@6
[Debug] drop_value: place: var@5
[Debug] drop_value: place: tl
[Debug] drop_value: place: hd
[Debug] drop_value: place: var@2
[Debug] drop_value: place: l
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, test1::List::Nil) ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> (0: i32, test1::List::Nil) ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@5 -> ⊥ : i32 ;
  var@6 -> ⊥ : test1::List<i32> ;
  var@7 -> ⊥ : bool ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@0

[Debug] Value to move:
(0: i32, test1::List::Nil)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (0: i32, test1::List::Nil) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: hd := copy (var@6).0
tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (0: i32, test1::List::Nil) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: hd := copy (var@6).0

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (0: i32, test1::List::Nil) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
copy (var@6).0

[Debug] Value to copy:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (0: i32, test1::List::Nil) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: tl := move (var@6).1
var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (0: i32, test1::List::Nil) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: tl := move (var@6).1

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (0: i32, test1::List::Nil) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move (var@6).1

[Debug] Value to move:
test1::List::Nil
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@10 := copy hd
var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@10 := copy hd

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
copy hd

[Debug] Value to copy:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> 0: i32 ;
}

About to evaluate statement: var@9 := move var@10 == 0: i32
var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> 0: i32 ;
}

About to evaluate statement: var@9 := move var@10 == 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> 0: i32 ;
}


- op:
move var@10

[Debug] Value to move:
0: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> true ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := ¬ move var@9
assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> true ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := ¬ move var@9

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> true ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@9

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> false ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@8)
drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> false ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@8)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> false ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@8

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: drop(tl)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> test1::List::Nil ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: drop(tl)

[Debug] drop_value: place: tl
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  hd -> 0: i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (0: i32, ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: get_elem_test
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32
y := 0: i32
var@5 := &mut x
var@4 := &two-phase *(var@5)
var@7 := &mut y
var@6 := &two-phase *(var@7)
z := move get_elem<i32>(true, move var@4, move var@6)
var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: x := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : i32 ;
  y -> ⊥ : i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⊥ : i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: y := 0: i32
var@5 := &mut x
var@4 := &two-phase *(var@5)
var@7 := &mut y
var@6 := &two-phase *(var@7)
z := move get_elem<i32>(true, move var@4, move var@6)
var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⊥ : i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: y := 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> ⊥ : i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@5 := &mut x
var@4 := &two-phase *(var@5)
var@7 := &mut y
var@6 := &two-phase *(var@7)
z := move get_elem<i32>(true, move var@4, move var@6)
var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@5 := &mut x

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (0: i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@4 := &two-phase *(var@5)
var@7 := &mut y
var@6 := &two-phase *(var@7)
z := move get_elem<i32>(true, move var@4, move var@6)
var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (0: i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@4 := &two-phase *(var@5)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := &mut y
var@6 := &two-phase *(var@7)
z := move get_elem<i32>(true, move var@4, move var@6)
var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@7 := &mut y

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := &two-phase *(var@7)
z := move get_elem<i32>(true, move var@4, move var@6)
var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@6 := &two-phase *(var@7)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⌊inactivated_mut@3⌋ ;
  var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: z := move get_elem<i32>(true, move var@4, move var@6)
var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⌊inactivated_mut@3⌋ ;
  var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: z := move get_elem<i32>(true, move var@4, move var@6)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⌊inactivated_mut@3⌋ ;
  var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
true

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⌊inactivated_mut@1⌋ ;
  var@5 -> &mut@0 (@shared_loan({1}, 0: i32)) ;
  var@6 -> ⌊inactivated_mut@3⌋ ;
  var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@4

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Concrete (Values.Scalar { Values.value = 0; int_ty = Types.I32 }));
  ty = (Types.Integer Types.I32) }
[Debug] Value to move:
&mut@1 (0: i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⌊inactivated_mut@3⌋ ;
  var@7 -> &mut@2 (@shared_loan({3}, 0: i32)) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@6

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Concrete (Values.Scalar { Values.value = 0; int_ty = Types.I32 }));
  ty = (Types.Integer Types.I32) }
[Debug] Value to move:
&mut@3 (0: i32)
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut (i32) ;
  b -> true ;
  x -> &mut@1 (0: i32) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> ⊥ : bool ;
}

About to evaluate statement: var@4 := copy b
if (move var@4) {
  var@0 := &mut *(x)
}
else {
  var@0 := move y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut (i32) ;
  b -> true ;
  x -> &mut@1 (0: i32) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> ⊥ : bool ;
}

About to evaluate statement: var@4 := copy b

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut (i32) ;
  b -> true ;
  x -> &mut@1 (0: i32) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> ⊥ : bool ;
}


- op:
copy b

[Debug] Value to copy:
true
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut (i32) ;
  b -> true ;
  x -> &mut@1 (0: i32) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> true ;
}

About to evaluate statement: if (move var@4) {
  var@0 := &mut *(x)
}
else {
  var@0 := move y
}
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut (i32) ;
  b -> true ;
  x -> &mut@1 (0: i32) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> true ;
}

About to evaluate statement: if (move var@4) {
  var@0 := &mut *(x)
}
else {
  var@0 := move y
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut (i32) ;
  b -> true ;
  x -> &mut@1 (0: i32) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> true ;
}


- op:
move var@4

[Debug] Value to move:
true
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut (i32) ;
  b -> true ;
  x -> &mut@1 (0: i32) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> ⊥ : bool ;
}

About to evaluate statement: var@0 := &mut *(x)

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> &mut@4 (0: i32) ;
  b -> true ;
  x -> &mut@1 (⌊mut@4⌋) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> ⊥ : bool ;
}

About to evaluate statement: return

[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> &mut@4 (0: i32) ;
  b -> true ;
  x -> &mut@1 (⌊mut@4⌋) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> ⊥ : bool ;
}

[Debug] ctx_pop_frame: locals to drop: [4,3,2,1]
[Debug] drop_value: place: var@4
[Debug] drop_value: place: y
[Debug] drop_value: place: x
[Debug] drop_value: place: b
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> &mut@4 (0: i32) ;
  b -> ⊥ : bool ;
  x -> ⊥ : &'_ mut (i32) ;
  y -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : bool ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

# Frame 1:
{
  var@0 -> &mut@4 (0: i32) ;
  b -> ⊥ : bool ;
  x -> ⊥ : &'_ mut (i32) ;
  y -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : bool ;
}


- op:
move var@0

[Debug] Value to move:
&mut@4 (0: i32)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (0: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := copy *(z)
*(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (0: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@8 := copy *(z)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (0: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> ⊥ : i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy *(z)

[Debug] Value to copy:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (0: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: *(z) := copy var@8 + 1: i32
var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (0: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: *(z) := copy var@8 + 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (0: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy var@8

[Debug] Value to copy:
0: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (0: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@12 := copy *(z)
var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@12 := copy *(z)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy *(z)

[Debug] Value to copy:
1: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> 1: i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@11 := move var@12 == 1: i32
var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> 1: i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@11 := move var@12 == 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> 1: i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@12

[Debug] Value to move:
1: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> true ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@10 := ¬ move var@11
assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> true ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@10 := ¬ move var@11

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> true ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@11

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> false ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@10)
var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> false ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@10)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> false ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@10

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@15 := copy x
var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@15 := copy x

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (1: i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@4⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy x

[Debug] Value to copy:
1: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> 1: i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@14 := move var@15 == 1: i32
var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> 1: i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@14 := move var@15 == 1: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> 1: i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@15

[Debug] Value to move:
1: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
1: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> true ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@13 := ¬ move var@14
assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> true ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@13 := ¬ move var@14

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> true ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@14

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> false ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@13)
var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> false ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@13)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> false ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@13

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@18 := copy y
var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@18 := copy y

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (0: i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
copy y

[Debug] Value to copy:
0: i32
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> 0: i32 ;
}

About to evaluate statement: var@17 := move var@18 == 0: i32
var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> 0: i32 ;
}

About to evaluate statement: var@17 := move var@18 == 0: i32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> 0: i32 ;
}


- op:
move var@18

[Debug] Value to move:
0: i32
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> true ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@16 := ¬ move var@17
assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> true ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: var@16 := ¬ move var@17

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> true ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@17

[Debug] Value to move:
true
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> false ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@16)
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> false ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: assert(¬move var@16)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> false ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@16

[Debug] Value to move:
false
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 1: i32 ;
  y -> 0: i32 ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> 0: i32 ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}

About to evaluate statement: return

[Debug] test_unit_function: id_mut_pair_test1
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: x := 0: u32
px := &mut x
var@4 := move px
(p).0 := move var@4
(p).1 := 1: u32
pp0 := &mut p
var@7 := &two-phase *(pp0)
pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: x := 0: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⊥ : u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
0: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: px := &mut x
var@4 := move px
(p).0 := move var@4
(p).1 := 1: u32
pp0 := &mut p
var@7 := &two-phase *(pp0)
pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: px := &mut x

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> &mut@0 (0: u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: var@4 := move px
(p).0 := move var@4
(p).1 := 1: u32
pp0 := &mut p
var@7 := &two-phase *(pp0)
pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> &mut@0 (0: u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: var@4 := move px

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> &mut@0 (0: u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
move px

[Debug] Value to move:
&mut@0 (0: u32)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> &mut@0 (0: u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: (p).0 := move var@4
(p).1 := 1: u32
pp0 := &mut p
var@7 := &two-phase *(pp0)
pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> &mut@0 (0: u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: (p).0 := move var@4

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⊥ : (&'_ mut (u32), u32) ;
  var@4 -> &mut@0 (0: u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
move var@4

[Debug] Value to move:
&mut@0 (0: u32)
[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjTuple 2), 0))
ty: (Types.Adt (Types.Tuple, [],
   [(Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut));
     (Types.Integer Types.U32)]
   ))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> (&mut@0 (0: u32), ⊥ : u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: (p).1 := 1: u32
pp0 := &mut p
var@7 := &two-phase *(pp0)
pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> (&mut@0 (0: u32), ⊥ : u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: (p).1 := 1: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> (&mut@0 (0: u32), ⊥ : u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
1: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> (&mut@0 (0: u32), 1: u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: pp0 := &mut p
var@7 := &two-phase *(pp0)
pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> (&mut@0 (0: u32), 1: u32) ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: pp0 := &mut p

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 ((&mut@0 (0: u32), 1: u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: var@7 := &two-phase *(pp0)
pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 ((&mut@0 (0: u32), 1: u32)) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: var@7 := &two-phase *(pp0)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⌊inactivated_mut@2⌋ ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: pp1 := move id_mut_pair<u32>(move var@7)
y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⌊inactivated_mut@2⌋ ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: pp1 := move id_mut_pair<u32>(move var@7)

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⌊inactivated_mut@2⌋ ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
move var@7

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Adt
     { Values.variant_id = <opaque>;
       field_values =
       [{ Values.value =
          (Values.Borrow
             (Values.MutBorrow (<opaque>,
                { Values.value =
                  (Values.Concrete
                     (Values.Scalar { Values.value = 0; int_ty = Types.U32 }));
                  ty = (Types.Integer Types.U32) }
                )));
          ty =
          (Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut)) };
         { Values.value =
           (Values.Concrete
              (Values.Scalar { Values.value = 1; int_ty = Types.U32 }));
           ty = (Types.Integer Types.U32) }
         ]
       });
  ty =
  (Types.Adt (Types.Tuple, [],
     [(Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut));
       (Types.Integer Types.U32)]
     ))
  }
[Debug] Value to move:
&mut@2 ((&mut@0 (0: u32), 1: u32))
[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@2⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  x -> &mut@2 ((&mut@0 (0: u32), 1: u32)) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
}

About to evaluate statement: var@2 := &mut *(x)
var@0 := &mut *(var@2)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@2⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  x -> &mut@2 ((&mut@0 (0: u32), 1: u32)) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
}

About to evaluate statement: var@2 := &mut *(x)

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@2⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  x -> &mut@2 (⌊mut@3⌋) ;
  var@2 -> &mut@3 ((&mut@0 (0: u32), 1: u32)) ;
}

About to evaluate statement: var@0 := &mut *(var@2)
return

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@2⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  x -> &mut@2 (⌊mut@3⌋) ;
  var@2 -> &mut@3 ((&mut@0 (0: u32), 1: u32)) ;
}

About to evaluate statement: var@0 := &mut *(var@2)

[Debug] 
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@2⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  x -> &mut@2 (⌊mut@3⌋) ;
  var@2 -> &mut@3 (⌊mut@4⌋) ;
}

About to evaluate statement: return

[Debug] ctx_pop_frame:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@2⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  x -> &mut@2 (⌊mut@3⌋) ;
  var@2 -> &mut@3 (⌊mut@4⌋) ;
}

[Debug] ctx_pop_frame: locals to drop: [2,1]
[Debug] drop_value: place: var@2
[Debug] drop_value: place: x
[Debug] ctx_pop_frame: after dropping local variables:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  x -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
}

[Debug] eval_operand:
- ctx:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  x -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
}


- op:
move var@0

[Debug] Value to move:
&mut@4 ((&mut@0 (0: u32), 1: u32))
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: y := 2: u32
var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: y := 2: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
2: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> 2: u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: var@10 := &mut y
var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> 2: u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

About to evaluate statement: var@10 := &mut y

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@5 (2: u32) ;
}

About to evaluate statement: var@9 := &mut *(var@10)
*((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@5 (2: u32) ;
}

About to evaluate statement: var@9 := &mut *(var@10)

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> &mut@6 (2: u32) ;
  var@10 -> &mut@5 (⌊mut@6⌋) ;
}

About to evaluate statement: *((pp1).0) := move var@9
*((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> &mut@6 (2: u32) ;
  var@10 -> &mut@5 (⌊mut@6⌋) ;
}

About to evaluate statement: *((pp1).0) := move var@9

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> &mut@6 (2: u32) ;
  var@10 -> &mut@5 (⌊mut@6⌋) ;
}


- op:
move var@9

[Debug] Value to move:
&mut@6 (2: u32)
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@6 (2: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@5 (⌊mut@6⌋) ;
}

About to evaluate statement: *((pp1).1) := 3: u32
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@6 (2: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@5 (⌊mut@6⌋) ;
}

About to evaluate statement: *((pp1).1) := 3: u32

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@6 (2: u32), 1: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@5 (⌊mut@6⌋) ;
}


- op:
3: u32

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> 0: u32 ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> &mut@4 ((&mut@6 (2: u32), 3: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@5⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@5 (⌊mut@6⌋) ;
}

About to evaluate statement: return

[Debug] test_unit_function: test_char
[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : char ;
}

About to evaluate statement: var@0 := a
return

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : char ;
}

About to evaluate statement: var@0 := a

[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : char ;
}


- op:
a

[Debug] 
# 1 frame(s)

# Frame 0:
{
  var@0 -> a ;
}

About to evaluate statement: return