Update the Makefile to make sure the execution trace always remains the

same

2 files changed, 16977 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index c44454e9..d9159a1a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,7 @@
 all:
-	dune build src/main.exe && dune exec src/main.exe
+	dune build src/main.exe && \
+	dune exec src/main.exe > trace_current.txt && \
+	cmp trace_reference.txt trace_current.txt
 
 doc:
 	dune build @doc
diff --git a/trace_reference.txt b/trace_reference.txt
new file mode 100644
index 00000000..ee8828da
--- /dev/null
+++ b/trace_reference.txt
@@ -0,0 +1,16974 @@
+[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_test() {
+  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 := 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
+          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_test
+[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] drop_borrows_loans_at_lplace: dropping 0
+[Debug] end_borrow 0: context before:
+# 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 (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 ;
+}
+
+[Debug] end_borrow 0: context after:
+# 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 (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 ;
+}
+
+[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] end_borrow 2: context before:
+# 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 ;
+}
+
+[Debug] end_borrow 2: context after:
+# 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 ;
+}
+
+[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] end_borrow 3: context before:
+# 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 ;
+}
+
+[Debug] end_borrow 3: context after:
+# 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 ;
+}
+
+[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] end_borrow 1: context before:
+# 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 ;
+}
+
+[Debug] end_borrow 1: context after:
+# 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 ;
+}
+
+[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 <opaque>);
+          ty = (Types.Integer Types.I32) }
+         ]
+       });
+  ty =
+  (Types.Adt ((Types.Assumed Types.Box), [], [(Types.Integer Types.I32)])) }
+[Debug] end_borrows {}: context before:
+# 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 ;
+}
+
+[Debug] end_borrows {}: context after:
+# 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 ;
+}
+
+[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] drop_borrows_loans_at_lplace: dropping 0
+[Debug] end_borrow 0: context before:
+# 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] end_borrow 0: context after:
+# 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] 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] end_borrow 1: context before:
+# 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 ;
+}
+
+[Debug] end_borrow 1: context after:
+# 1 frame(s)
+
+# Frame 0:
+{
+  var@0 -> ⊥ : () ;
+  b -> @Box(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 ;
+}
+
+[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] drop_borrows_loans_at_lplace: dropping 2
+[Debug] end_borrow 2: context before:
+# 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] end_borrow 2: context after:
+# 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] 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] end_borrows {3}: context before:
+# 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 ;
+}
+
+[Debug] end_borrows {3}: context after:
+# 1 frame(s)
+
+# Frame 0:
+{
+  var@0 -> ⊥ : () ;
+  b -> @Box(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 ;
+}
+
+[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] drop_borrows_loans_at_lplace: dropping 1
+[Debug] end_borrow 1: context before:
+# 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] end_borrow 1: context after:
+# 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] 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] end_borrows {0}: context before:
+# 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⌋ ;
+}
+
+[Debug] end_borrows {0}: context after:
+# 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>) ;
+}
+
+[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 <opaque>); ty = (Types.Integer Types.I32) }
+[Debug] end_borrows {}: context before:
+# 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 ;
+}
+
+[Debug] end_borrows {}: context after:
+# 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 ;
+}
+
+[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 <opaque>); ty = (Types.Integer Types.I32) }
+[Debug] end_borrows {}: context before:
+# 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 ;
+}
+
+[Debug] end_borrows {}: context after:
+# 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 ;
+}
+
+[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_borrows_loans_at_lplace: dropping 3
+[Debug] end_borrow 3: context before:
+# 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] end_borrow 3: context after:
+# 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 (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 -> true ;
+  x -> &mut@1 (⌊mut@4⌋) ;
+  y -> ⊥ : &'_ mut (i32) ;
+  var@4 -> ⊥ : bool ;
+}
+
+[Debug] drop_value: place: x
+[Debug] drop_borrows_loans_at_lplace: dropping 1
+[Debug] end_borrow 1: context before:
+# 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 (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 -> true ;
+  x -> &mut@1 (⌊mut@4⌋) ;
+  y -> ⊥ : &'_ mut (i32) ;
+  var@4 -> ⊥ : bool ;
+}
+
+[Debug] end_borrow 1: context after:
+# 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 -> true ;
+  x -> ⊥ : &'_ mut (i32) ;
+  y -> ⊥ : &'_ mut (i32) ;
+  var@4 -> ⊥ : bool ;
+}
+
+[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] end_borrow 0: context before:
+# 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 ;
+}
+
+[Debug] end_borrow 0: context after:
+# 1 frame(s)
+
+# Frame 0:
+{
+  var@0 -> ⊥ : () ;
+  x -> ⌊mut@4⌋ ;
+  y -> ⌊mut@2⌋ ;
+  z -> &mut@4 (1: 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 ;
+}
+
+[Debug] end_borrow 4: context before:
+# 1 frame(s)
+
+# Frame 0:
+{
+  var@0 -> ⊥ : () ;
+  x -> ⌊mut@4⌋ ;
+  y -> ⌊mut@2⌋ ;
+  z -> &mut@4 (1: 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 ;
+}
+
+[Debug] end_borrow 4: context after:
+# 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 ;
+}
+
+[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] end_borrow 2: context before:
+# 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 ;
+}
+
+[Debug] end_borrow 2: context after:
+# 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 ;
+}
+
+[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 <opaque>);
+                  ty = (Types.Integer Types.U32) }
+                )));
+          ty =
+          (Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut)) };
+         { Values.value = (Values.Concrete <opaque>);
+           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] end_borrows {}: context before:
+# 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) ;
+}
+
+[Debug] end_borrows {}: context after:
+# 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) ;
+}
+
+[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_borrows_loans_at_lplace: dropping 3
+[Debug] end_borrow 3: context before:
+# 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] end_borrow 3: context after:
+# 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@4⌋) ;
+  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
+}
+
+[Debug] drop_value: place: x
+[Debug] drop_borrows_loans_at_lplace: dropping 2
+[Debug] end_borrow 2: context before:
+# 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@4⌋) ;
+  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
+}
+
+[Debug] end_borrow 2: context after:
+# 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] 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] drop_borrows_loans_at_lplace: dropping 0
+[Debug] end_borrow 0: context before:
+# 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 (⌊mut@6⌋) ;
+}
+
+[Debug] end_borrow 0: context after:
+# 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 (u32), 1: u32)) ;
+  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
+  y -> ⌊mut@5⌋ ;
+  var@9 -> ⊥ : &'_ mut (u32) ;
+  var@10 -> &mut@5 (⌊mut@6⌋) ;
+}
+
+[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
+