From 119de329f565281f5260b00cbc5fb623f6076ed4 Mon Sep 17 00:00:00 2001
From: Son Ho
Date: Tue, 7 Dec 2021 17:51:16 +0100
Subject: Move files around

---
 Makefile                  |     5 +-
 tests/trace_reference.txt | 16974 ++++++++++++++++++++++++++++++++++++++++++++
 trace_reference.txt       | 16974 --------------------------------------------
 3 files changed, 16977 insertions(+), 16976 deletions(-)
 create mode 100644 tests/trace_reference.txt
 delete mode 100644 trace_reference.txt

diff --git a/Makefile b/Makefile
index d9159a1a..391a9ee7 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,8 @@
 all:
 	dune build src/main.exe && \
-	dune exec src/main.exe > trace_current.txt && \
-	cmp trace_reference.txt trace_current.txt
+	dune exec src/main.exe > tests/trace_current.txt && \
+	cmp tests/trace_reference.txt tests/trace_current.txt && \
+	rm tests/trace_current.txt
 
 doc:
 	dune build @doc
diff --git a/tests/trace_reference.txt b/tests/trace_reference.txt
new file mode 100644
index 00000000..ee8828da
--- /dev/null
+++ b/tests/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
+
diff --git a/trace_reference.txt b/trace_reference.txt
deleted file mode 100644
index ee8828da..00000000
--- a/trace_reference.txt
+++ /dev/null
@@ -1,16974 +0,0 @@
-[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
-
-- 
cgit v1.2.3