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

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

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

enum test1::EmptyEnum =
|  Empty()

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

struct test1::EmptyStruct{}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  var@0 := copy x;
  return
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  var@0 := copy x;
  return
}

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

  var@0 := a;
  return
}

[Debug] test_unit_function: test2
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 23: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := 44: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  z := 67: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := copy x
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  (p).x := move var@5
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  (p).y := 67: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(s, 1)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  set_discriminant(o, 0);
  set_discriminant(e0, 0);
  set_discriminant(enum0, 0);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(o, 0)
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(e0, 0);
  set_discriminant(enum0, 0);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(e0, 0)
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(enum0, 0);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(enum0, 0)
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 ;
}



[Debug] test_unit_function: test3
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := move get_max(4: u32, 3: u32)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := copy x
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := copy y
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@3 := move var@4 >= move var@5
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  if (move var@3) {
    var@0 := copy x
  }
  else {
    var@0 := copy y
  };
  return
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@0 := copy x
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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:
# 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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := move get_max(10: u32, 11: u32)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := copy x
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := copy y
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@3 := move var@4 >= move var@5
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  if (move var@3) {
    var@0 := copy x
  }
  else {
    var@0 := copy y
  };
  return
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@0 := copy y
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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:
# 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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := copy x
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := copy y
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  z := copy var@4 + copy var@5
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@9 := copy z
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@8 := move var@9 == 15: u32;
  var@7 := ¬ move var@8;
  assert(¬move var@7);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := move var@9 == 15: u32
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@7 := ¬ move var@8;
  assert(¬move var@7);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := ¬ move var@8
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  assert(¬move var@7);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@7)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 ;
}



[Debug] test_unit_function: test_neg1
[Debug] 
**About to evaluate statement**: [
  x := 3: i32;
  y := -3: i32;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  x := 3: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
3: i32

[Debug] 
**About to evaluate statement**: [
  y := -3: i32;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  y := -3: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
-3: i32

[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
0: i32

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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  px := &mut x
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  ppx := &mut px
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

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


- op:
1: i32

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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@6 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
1: i32
[Debug] 
**About to evaluate statement**: [
  var@5 := move var@6 == 1: i32;
  var@4 := ¬ move var@5;
  assert(¬move var@4);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@5 := move var@6 == 1: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@6

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

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


- op:
1: i32

[Debug] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5;
  assert(¬move var@4);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@5

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@4);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@4)
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@4

[Debug] Value to move:
false
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_unit_function: refs_test2
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := 1: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  px := &mut x
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  py := &mut y
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  ppx := &mut px
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@9 := copy *(px)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy *(px)

[Debug] Value to copy:
2: i32
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := move var@9 == 2: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := ¬ move var@8
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@7)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@12 := copy x
]

**Context**:
# 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] 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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@11 := move var@12 == 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@10 := ¬ move var@11
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@10)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@15 := copy *(py)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy *(py)

[Debug] Value to copy:
2: i32
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@14 := move var@15 == 2: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@13 := ¬ move var@14
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@13)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@18 := copy y
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy y

[Debug] Value to copy:
2: i32
[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 2: i32;
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 2: i32
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  assert(¬move var@16);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@16)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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] test_unit_function: test_list1
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  set_discriminant(var@3, 1)
]

**Context**:
# 1 frame(s)

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



[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



[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] 
**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
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> @Box(test1::List::Nil) ;
  var@3 -> ⊥ : test1::List<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] 
**About to evaluate statement**: [
  (l as test1::List::Cons).1 := move var@2;
  set_discriminant(l, 0);
  drop(l);
  return
]

**Context**:
# 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> ;
}



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

**Context**:
# 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> ;
}



[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] 
**About to evaluate statement**: [
  set_discriminant(l, 0);
  drop(l);
  return
]

**Context**:
# 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> ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(l, 0)
]

**Context**:
# 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> ;
}



[Debug] 
**About to evaluate statement**: [
  drop(l);
  return
]

**Context**:
# 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> ;
}



[Debug] 
**About to evaluate statement**: [
  drop(l)
]

**Context**:
# 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> ;
}



[Debug] drop_value: place: l
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_unit_function: test_box1
[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@3 := &two-phase b
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3)
]

**Context**:
# 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] eval_non_local_function_call:
- fid:CfimAst.BoxDerefMut
- type_params: [i32]
- args: [move var@3]
- dest: x
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
move var@3

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

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

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

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

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

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

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

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

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


- op:
move @return

[Debug] Value to move:
&mut@1 (0: i32)
[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@5 := &b
]

**Context**:
# 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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



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

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


- op:
move var@5

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

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

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

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

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

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

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

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

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


- op:
move @return

[Debug] Value to move:
⌊shared@3⌋
[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@8 := copy *(x)
]

**Context**:
# 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] 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] 
**About to evaluate statement**: [
  var@7 := move var@8 == 1: i32;
  var@6 := ¬ move var@7;
  assert(¬move var@6);
  drop(b);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := move var@8 == 1: i32
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@6 := ¬ move var@7;
  assert(¬move var@6);
  drop(b);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := ¬ move var@7
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  assert(¬move var@6);
  drop(b);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@6)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  drop(b);
  return
]

**Context**:
# 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] 
**About to evaluate statement**: [
  drop(b)
]

**Context**:
# 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] drop_value: place: b
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 ;
}



[Debug] test_unit_function: test_copy_int
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  px := &x
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := copy x
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := move copy_int(move var@4)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@0 := copy x;
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := copy x
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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:
# 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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := copy y
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@6 := move var@7 == move var@8;
  var@5 := ¬ move var@6;
  assert(¬move var@5);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := move var@7 == move var@8
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@5 := ¬ move var@6;
  assert(¬move var@5);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := ¬ move var@6
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  assert(¬move var@5);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@5)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 ;
}



[Debug] test_unit_function: test_is_cons
[Debug] 
**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
]

**Context**:
# 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>) ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(var@3, 1)
]

**Context**:
# 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>) ;
}



[Debug] 
**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
]

**Context**:
# 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>) ;
}



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

**Context**:
# 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>) ;
}



[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] 
**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
]

**Context**:
# 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>) ;
}



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

**Context**:
# 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>) ;
}



[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] 
**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
]

**Context**:
# 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>) ;
}



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

**Context**:
# 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>) ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  set_discriminant(l, 0)
]

**Context**:
# 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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@7 := &l
]

**Context**:
# 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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@6 := copy var@7
]

**Context**:
# 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] 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] 
**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
]

**Context**:
# 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⌋ ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := move is_cons<i32>(move var@6)
]

**Context**:
# 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⌋ ;
}



[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] 
**About to evaluate statement**: [
  var@2 := discriminant(*(l));
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  };
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := discriminant(*(l))
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  };
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@0 := true
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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:
# 2 frame(s)

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

# Frame 1:
{
  var@0 -> true ;
  l -> ⌊shared@1⌋ ;
  var@2 -> ⊥ : isize ;
}

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

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

# Frame 1:
{
  var@0 -> true ;
  l -> ⊥ : &'_ (test1::List<i32>) ;
  var@2 -> ⊥ : isize ;
}

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

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

# Frame 1:
{
  var@0 -> true ;
  l -> ⊥ : &'_ (test1::List<i32>) ;
  var@2 -> ⊥ : isize ;
}


- op:
move var@0

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5;
  assert(¬move var@4);
  drop(l);
  return
]

**Context**:
# 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⌋ ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5
]

**Context**:
# 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⌋ ;
}



[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] 
**About to evaluate statement**: [
  assert(¬move var@4);
  drop(l);
  return
]

**Context**:
# 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⌋ ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@4)
]

**Context**:
# 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⌋ ;
}



[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] 
**About to evaluate statement**: [
  drop(l);
  return
]

**Context**:
# 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] 
**About to evaluate statement**: [
  drop(l)
]

**Context**:
# 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] drop_value: place: l
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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>) ;
}



[Debug] test_unit_function: test_split_list
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(var@3, 1)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(l, 0)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := move l
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := move split_list<i32>(move var@7)
]

**Context**:
# 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 ;
}



[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] 
**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
    }
  }
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := false
]

**Context**:
# 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 ;
}



[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] 
**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
    }
  }
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := false
]

**Context**:
# 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 ;
}



[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] 
**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
    }
  }
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := true
]

**Context**:
# 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 ;
}



[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] 
**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
    }
  }
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := true
]

**Context**:
# 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 ;
}



[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] 
**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
    }
  }
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := discriminant(l)
]

**Context**:
# 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 ;
}



[Debug] 
**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
    }
  }
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := false
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  hd := move (l as test1::List::Cons).0
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := false
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  tl := move (l as test1::List::Cons).1
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := move hd
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := move deref_box(tl)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  (var@0).0 := move var@5
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  (var@0).1 := move var@6;
  var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  (var@0).1 := move var@6
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@9 := move alloc::alloc::box_free<test1::List<i32>>(move tl)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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:
# 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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  hd := copy (var@6).0
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  tl := move (var@6).1
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@10 := copy hd
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@9 := move var@10 == 0: i32;
  var@8 := ¬ move var@9;
  assert(¬move var@8);
  drop(tl);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@9 := move var@10 == 0: i32
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@8 := ¬ move var@9;
  assert(¬move var@8);
  drop(tl);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := ¬ move var@9
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  assert(¬move var@8);
  drop(tl);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@8)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  drop(tl);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  drop(tl)
]

**Context**:
# 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 ;
}



[Debug] drop_value: place: tl
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 ;
}



[Debug] test_unit_function: get_elem_test
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := &mut x
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := &two-phase *(var@5)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := &mut y
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := &two-phase *(var@7)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  z := move get_elem<i32>(true, move var@4, move var@6)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
true

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

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


- op:
move var@4

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Concrete (Values.Scalar { Values.value = 0; int_ty = Types.I32 }));
  ty = (Types.Integer Types.I32) }
[Debug] Value to move:
&mut@1 (0: i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
move var@6

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Concrete (Values.Scalar { Values.value = 0; int_ty = Types.I32 }));
  ty = (Types.Integer Types.I32) }
[Debug] Value to move:
&mut@3 (0: i32)
[Debug] 
**About to evaluate statement**: [
  var@4 := copy b;
  if (move var@4) {
    var@0 := &mut *(x)
  }
  else {
    var@0 := move y
  };
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := copy b
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  if (move var@4) {
    var@0 := &mut *(x)
  }
  else {
    var@0 := move y
  };
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  if (move var@4) {
    var@0 := &mut *(x)
  }
  else {
    var@0 := move y
  }
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@0 := &mut *(x)
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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:
# 2 frame(s)

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

# Frame 1:
{
  var@0 -> &mut@4 (0: i32) ;
  b -> true ;
  x -> &mut@1 (⌊mut@4⌋) ;
  y -> &mut@3 (0: i32) ;
  var@4 -> ⊥ : bool ;
}

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

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

# Frame 1:
{
  var@0 -> &mut@4 (0: i32) ;
  b -> ⊥ : bool ;
  x -> ⊥ : &'_ mut (i32) ;
  y -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : bool ;
}

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

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

# Frame 1:
{
  var@0 -> &mut@4 (0: i32) ;
  b -> ⊥ : bool ;
  x -> ⊥ : &'_ mut (i32) ;
  y -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : bool ;
}


- op:
move var@0

[Debug] Value to move:
&mut@4 (0: i32)
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := copy *(z)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  *(z) := copy var@8 + 1: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@12 := copy *(z)
]

**Context**:
# 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] 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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@11 := move var@12 == 1: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@10 := ¬ move var@11
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@10)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@15 := copy x
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy x

[Debug] Value to copy:
1: i32
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@14 := move var@15 == 1: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@13 := ¬ move var@14
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@13)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@18 := copy y
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy y

[Debug] Value to copy:
0: i32
[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 0: i32;
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 0: i32
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  assert(¬move var@16);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@16)
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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] test_unit_function: id_mut_pair_test1
[Debug] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: u32
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  px := &mut x
]

**Context**:
# 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) ;
}



[Debug] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := move px
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  (p).0 := move var@4
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  (p).1 := 1: u32
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  pp0 := &mut p
]

**Context**:
# 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) ;
}



[Debug] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := &two-phase *(pp0)
]

**Context**:
# 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) ;
}



[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  pp1 := move id_mut_pair<u32>(move var@7)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⌊inactivated_mut@2⌋ ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
move var@7

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Adt
     { Values.variant_id = <opaque>;
       field_values =
       [{ Values.value =
          (Values.Borrow
             (Values.MutBorrow (<opaque>,
                { Values.value =
                  (Values.Concrete
                     (Values.Scalar { Values.value = 0; int_ty = Types.U32 }));
                  ty = (Types.Integer Types.U32) }
                )));
          ty =
          (Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut)) };
         { Values.value =
           (Values.Concrete
              (Values.Scalar { Values.value = 1; int_ty = Types.U32 }));
           ty = (Types.Integer Types.U32) }
         ]
       });
  ty =
  (Types.Adt (Types.Tuple, [],
     [(Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut));
       (Types.Integer Types.U32)]
     ))
  }
[Debug] Value to move:
&mut@2 ((&mut@0 (0: u32), 1: u32))
[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x);
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 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)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x)
]

**Context**:
# 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)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 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)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2)
]

**Context**:
# 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)) ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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:
# 2 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@2⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  x -> &mut@2 (⌊mut@3⌋) ;
  var@2 -> &mut@3 (⌊mut@4⌋) ;
}

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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  x -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
}

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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (⌊mut@4⌋) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}

# Frame 1:
{
  var@0 -> &mut@4 ((&mut@0 (0: u32), 1: u32)) ;
  x -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
}


- op:
move var@0

[Debug] Value to move:
&mut@4 ((&mut@0 (0: u32), 1: u32))
[Debug] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  y := 2: u32
]

**Context**:
# 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) ;
}



[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] 
**About to evaluate statement**: [
  var@10 := &mut y;
  var@9 := &mut *(var@10);
  *((pp1).0) := move var@9;
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  var@10 := &mut y
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  var@9 := &mut *(var@10);
  *((pp1).0) := move var@9;
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  var@9 := &mut *(var@10)
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  *((pp1).0) := move var@9;
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 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⌋) ;
}



[Debug] 
**About to evaluate statement**: [
  *((pp1).0) := move var@9
]

**Context**:
# 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⌋) ;
}



[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] 
**About to evaluate statement**: [
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 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⌋) ;
}



[Debug] 
**About to evaluate statement**: [
  *((pp1).1) := 3: u32
]

**Context**:
# 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⌋) ;
}



[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] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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⌋) ;
}



[Debug] test_unit_function: test_char
[Debug] 
**About to evaluate statement**: [
  var@0 := a;
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : char ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := a
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : char ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : char ;
}


- op:
a

[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> a ;
}



[Debug] test_function_symbolic: add_test
[Debug] 
**About to evaluate statement**: [
  var@3 := copy x;
  var@4 := copy y;
  var@0 := copy var@3 + copy var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@3 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] 
**About to evaluate statement**: [
  var@4 := copy y;
  var@0 := copy var@3 + copy var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := copy y
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy y

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  var@0 := copy var@3 + copy var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@0 := copy var@3 + copy var@4
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy var@3

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy var@4

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> proj_comp {} (s@2 : u32) ;
  x -> proj_comp {} (s@0 : u32) ;
  y -> proj_comp {} (s@1 : u32) ;
  var@3 -> proj_comp {} (s@0 : u32) ;
  var@4 -> proj_comp {} (s@1 : u32) ;
  var@5 -> ⊥ : (u32, bool) ;
}



[Debug] test_function_symbolic: subs_test
[Debug] 
**About to evaluate statement**: [
  var@3 := copy x;
  var@4 := copy y;
  var@0 := copy var@3 - copy var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@3 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] 
**About to evaluate statement**: [
  var@4 := copy y;
  var@0 := copy var@3 - copy var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := copy y
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy y

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  var@0 := copy var@3 - copy var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@0 := copy var@3 - copy var@4
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy var@3

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy var@4

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> proj_comp {} (s@2 : u32) ;
  x -> proj_comp {} (s@0 : u32) ;
  y -> proj_comp {} (s@1 : u32) ;
  var@3 -> proj_comp {} (s@0 : u32) ;
  var@4 -> proj_comp {} (s@1 : u32) ;
  var@5 -> ⊥ : (u32, bool) ;
}



[Debug] test_function_symbolic: div_test
[Debug] 
**About to evaluate statement**: [
  var@3 := copy x;
  var@4 := copy y;
  var@0 := move var@3 / move var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@3 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] 
**About to evaluate statement**: [
  var@4 := copy y;
  var@0 := move var@3 / move var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := copy y
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy y

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  var@0 := move var@3 / move var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@0 := move var@3 / move var@4
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@3

[Debug] Value to move:
proj_comp {} (s@0 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
move var@4

[Debug] Value to move:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_function_symbolic: rem_test
[Debug] 
**About to evaluate statement**: [
  var@3 := copy x;
  var@4 := copy y;
  var@0 := move var@3 % move var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@3 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] 
**About to evaluate statement**: [
  var@4 := copy y;
  var@0 := move var@3 % move var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := copy y
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy y

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  var@0 := move var@3 % move var@4;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@0 := move var@3 % move var@4
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@3

[Debug] Value to move:
proj_comp {} (s@0 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
move var@4

[Debug] Value to move:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_function_symbolic: test2
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 23: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := 44: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  z := 67: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := copy x
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  (p).x := move var@5
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  (p).y := 67: u32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(s, 1)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  set_discriminant(o, 0);
  set_discriminant(e0, 0);
  set_discriminant(enum0, 0);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(o, 0)
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(e0, 0);
  set_discriminant(enum0, 0);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(e0, 0)
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(enum0, 0);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(enum0, 0)
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 ;
}



[Debug] test_function_symbolic: get_max
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@5 := copy y
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy y

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@3 := move var@4 >= move var@5
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@4

[Debug] Value to move:
proj_comp {} (s@0 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
move var@5

[Debug] Value to move:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  if (move var@3) {
    var@0 := copy x
  }
  else {
    var@0 := copy y
  };
  return
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@3

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  var@0 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : u32 ;
  x -> proj_comp {} (s@0 : u32) ;
  y -> proj_comp {} (s@1 : u32) ;
  var@3 -> false ;
  var@4 -> ⊥ : u32 ;
  var@5 -> ⊥ : u32 ;
}


- op:
move var@3

[Debug] Value to move:
false
[Debug] 
**About to evaluate statement**: [
  var@0 := copy y
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy y

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_function_symbolic: test3
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := move get_max(4: u32, 3: u32)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  y := move get_max(10: u32, 11: u32)
]

**Context**:
# 1 frame(s)

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



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {} (s@0 : 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 -> proj_comp {} (s@0 : 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] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := copy x
]

**Context**:
# 1 frame(s)

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



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {} (s@0 : u32) ;
  y -> proj_comp {} (s@1 : 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:
proj_comp {} (s@0 : u32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@5 := copy y
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy y

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  z := copy var@4 + copy var@5
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy var@4

[Debug] Value to copy:
proj_comp {} (s@0 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy var@5

[Debug] Value to copy:
proj_comp {} (s@1 : u32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@9 := copy z
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy z

[Debug] Value to copy:
proj_comp {} (s@2 : u32)
[Debug] 
**About to evaluate statement**: [
  var@8 := move var@9 == 15: u32;
  var@7 := ¬ move var@8;
  assert(¬move var@7);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@8 := move var@9 == 15: u32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@9

[Debug] Value to move:
proj_comp {} (s@2 : u32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
15: u32

[Debug] 
**About to evaluate statement**: [
  var@7 := ¬ move var@8;
  assert(¬move var@7);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@7 := ¬ move var@8
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@8

[Debug] Value to move:
proj_comp {} (s@3 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@7);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@7)
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@7

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_function_symbolic: test_neg
[Debug] 
**About to evaluate statement**: [
  var@2 := copy x;
  var@3 := copy var@2 == -2147483648: i32;
  assert(¬move var@3);
  var@0 := - move var@2;
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> ⊥ : i32 ;
  var@3 -> ⊥ : bool ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := copy x
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> ⊥ : i32 ;
  var@3 -> ⊥ : bool ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> ⊥ : i32 ;
  var@3 -> ⊥ : bool ;
}


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : i32)
[Debug] 
**About to evaluate statement**: [
  var@3 := copy var@2 == -2147483648: i32;
  assert(¬move var@3);
  var@0 := - move var@2;
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> ⊥ : bool ;
}



[Debug] 
**About to evaluate statement**: [
  var@3 := copy var@2 == -2147483648: i32
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> ⊥ : bool ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> ⊥ : bool ;
}


- op:
copy var@2

[Debug] Value to copy:
proj_comp {} (s@0 : i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> ⊥ : bool ;
}


- op:
-2147483648: i32

[Debug] 
**About to evaluate statement**: [
  assert(¬move var@3);
  var@0 := - move var@2;
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> proj_comp {} (s@1 : bool) ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@3)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> proj_comp {} (s@1 : bool) ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> true ;
}


- op:
move var@3

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  var@0 := - move var@2;
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> ⊥ : bool ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := - move var@2
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> ⊥ : bool ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : i32 ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> proj_comp {} (s@0 : i32) ;
  var@3 -> ⊥ : bool ;
}


- op:
move var@2

[Debug] Value to move:
proj_comp {} (s@0 : i32)
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> proj_comp {} (s@2 : i32) ;
  x -> proj_comp {} (s@0 : i32) ;
  var@2 -> ⊥ : i32 ;
  var@3 -> ⊥ : bool ;
}



[Debug] test_function_symbolic: test_neg1
[Debug] 
**About to evaluate statement**: [
  x := 3: i32;
  y := -3: i32;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  x := 3: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
3: i32

[Debug] 
**About to evaluate statement**: [
  y := -3: i32;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  y := -3: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
-3: i32

[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
0: i32

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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  px := &mut x
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  ppx := &mut px
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

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


- op:
1: i32

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

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@6 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
1: i32
[Debug] 
**About to evaluate statement**: [
  var@5 := move var@6 == 1: i32;
  var@4 := ¬ move var@5;
  assert(¬move var@4);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@5 := move var@6 == 1: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@6

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

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


- op:
1: i32

[Debug] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5;
  assert(¬move var@4);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@5

[Debug] Value to move:
proj_comp {} (s@0 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@4);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@4)
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@4

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_function_symbolic: refs_test2
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := 1: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  px := &mut x
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  py := &mut y
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  ppx := &mut px
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@9 := copy *(px)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy *(px)

[Debug] Value to copy:
2: i32
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := move var@9 == 2: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@0 : 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] 
**About to evaluate statement**: [
  var@7 := ¬ move var@8
]

**Context**:
# 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 -> proj_comp {} (s@0 : 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] 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 -> proj_comp {} (s@0 : 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@8

[Debug] Value to move:
proj_comp {} (s@0 : bool)
[Debug] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@1 : 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] 
**About to evaluate statement**: [
  assert(¬move var@7)
]

**Context**:
# 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 -> proj_comp {} (s@1 : 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] 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 -> true ;
  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:
true
[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@12 := copy x
]

**Context**:
# 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] 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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@11 := move var@12 == 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@2 : bool) ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  var@10 := ¬ move var@11
]

**Context**:
# 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 -> proj_comp {} (s@2 : bool) ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : 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 -> proj_comp {} (s@2 : 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@11

[Debug] Value to move:
proj_comp {} (s@2 : bool)
[Debug] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@3 : bool) ;
  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] 
**About to evaluate statement**: [
  assert(¬move var@10)
]

**Context**:
# 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 -> proj_comp {} (s@3 : bool) ;
  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] 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 -> true ;
  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:
true
[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@15 := copy *(py)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy *(py)

[Debug] Value to copy:
2: i32
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@14 := move var@15 == 2: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@4 : bool) ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  var@13 := ¬ move var@14
]

**Context**:
# 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 -> proj_comp {} (s@4 : bool) ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : 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 -> proj_comp {} (s@4 : bool) ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@14

[Debug] Value to move:
proj_comp {} (s@4 : bool)
[Debug] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@5 : bool) ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@13)
]

**Context**:
# 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 -> proj_comp {} (s@5 : bool) ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : 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 -> true ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@13

[Debug] Value to move:
true
[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  var@18 := copy y
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy y

[Debug] Value to copy:
2: i32
[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 2: i32;
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 2: i32
]

**Context**:
# 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 ;
}



[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] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 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 -> proj_comp {} (s@6 : bool) ;
  var@18 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17
]

**Context**:
# 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 -> proj_comp {} (s@6 : bool) ;
  var@18 -> ⊥ : 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 -> proj_comp {} (s@6 : bool) ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@17

[Debug] Value to move:
proj_comp {} (s@6 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@16);
  return
]

**Context**:
# 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 -> proj_comp {} (s@7 : bool) ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@16)
]

**Context**:
# 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 -> proj_comp {} (s@7 : bool) ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : 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 -> true ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@16

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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] test_function_symbolic: test_list1
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  set_discriminant(var@3, 1)
]

**Context**:
# 1 frame(s)

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



[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



[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] 
**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
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>) ;
  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] 
**About to evaluate statement**: [
  (l as test1::List::Cons).1 := move var@2;
  set_discriminant(l, 0);
  drop(l);
  return
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



[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 -> proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>) ;
  var@3 -> ⊥ : test1::List<i32> ;
}


- op:
move var@2

[Debug] Value to move:
proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>)
[Debug] 
**About to evaluate statement**: [
  set_discriminant(l, 0);
  drop(l);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  set_discriminant(l, 0)
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  drop(l);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  drop(l)
]

**Context**:
# 1 frame(s)

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



[Debug] drop_value: place: l
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_function_symbolic: test_box1
[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> proj_comp {} (s@0 : 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@3 := &two-phase b
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> proj_comp {} (s@0 : 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 ;
}



[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({0}, proj_comp {} (s@0 : std::boxed::Box<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] 
**About to evaluate statement**: [
  x := move core::ops::deref::DerefMut<i32>::deref_mut(move var@3)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({0}, proj_comp {} (s@0 : std::boxed::Box<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] 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}, proj_comp {} (s@0 : std::boxed::Box<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.Symbolic
     { Values.svalue =
       { Values.sv_id = 0;
         sv_ty =
         (Types.Adt ((Types.Assumed Types.Box), [],
            [(Types.Integer Types.I32)]))
         };
       rset_ended = {} });
  ty =
  (Types.Adt ((Types.Assumed Types.Box), [], [(Types.Integer Types.I32)])) }
[Debug] Value to move:
&mut@0 (proj_comp {} (s@0 : std::boxed::Box<i32>))
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⌊mut@0⌋ ;
  x -> proj_comp {} (s@1 : &r@0 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 ;
  abs@0{parents={}}{regions={0}} {
    &mut@0 (proj_borrows (s@0 : std::boxed::Box<i32> <: std::boxed::Box<i32>)),
    proj_loans (s@1 : &r@0 mut (i32))
  }
}



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

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⌊mut@0⌋ ;
  x -> proj_comp {} (s@1 : &r@0 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 ;
  abs@0{parents={}}{regions={0}} {
    &mut@0 (proj_borrows (s@0 : std::boxed::Box<i32> <: std::boxed::Box<i32>)),
    proj_loans (s@1 : &r@0 mut (i32))
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⌊mut@0⌋ ;
  x -> proj_comp {} (s@1 : &r@0 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 ;
  abs@0{parents={}}{regions={0}} {
    &mut@0 (proj_borrows (s@0 : std::boxed::Box<i32> <: std::boxed::Box<i32>)),
    proj_loans (s@1 : &r@0 mut (i32))
  }
}


- op:
1: i32

[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⌊mut@0⌋ ;
  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 ;
  abs@0{parents={}}{regions={0}} {
    &mut@0 (proj_borrows (s@0 : std::boxed::Box<i32> <: std::boxed::Box<i32>)),
    ⌊mut@1, proj_loans (s@2 : i32)⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  var@5 := &b
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> ⌊mut@0⌋ ;
  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 ;
  abs@0{parents={}}{regions={0}} {
    &mut@0 (proj_borrows (s@0 : std::boxed::Box<i32> <: std::boxed::Box<i32>)),
    ⌊mut@1, proj_loans (s@2 : i32)⌋
  }
}



[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 ;
}



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

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 ;
}



[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}, proj_comp {0} (s@3 : std::boxed::Box<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] 
**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
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

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


- op:
copy *(x)

[Debug] Value to copy:
proj_comp {} (s@5 : i32)
[Debug] 
**About to evaluate statement**: [
  var@7 := move var@8 == 1: i32;
  var@6 := ¬ move var@7;
  assert(¬move var@6);
  drop(b);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 -> proj_comp {} (s@5 : i32) ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}



[Debug] 
**About to evaluate statement**: [
  var@7 := move var@8 == 1: i32
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 -> proj_comp {} (s@5 : i32) ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 -> proj_comp {} (s@5 : i32) ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}


- op:
move var@8

[Debug] Value to move:
proj_comp {} (s@5 : i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}


- op:
1: i32

[Debug] 
**About to evaluate statement**: [
  var@6 := ¬ move var@7;
  assert(¬move var@6);
  drop(b);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 -> proj_comp {} (s@6 : bool) ;
  var@8 -> ⊥ : i32 ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}



[Debug] 
**About to evaluate statement**: [
  var@6 := ¬ move var@7
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 -> proj_comp {} (s@6 : bool) ;
  var@8 -> ⊥ : i32 ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 -> proj_comp {} (s@6 : bool) ;
  var@8 -> ⊥ : i32 ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}


- op:
move var@7

[Debug] Value to move:
proj_comp {} (s@6 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@6);
  drop(b);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@6)
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@6

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  drop(b);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}



[Debug] 
**About to evaluate statement**: [
  drop(b)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  b -> @shared_loan({2}, proj_comp {0} (s@3 : std::boxed::Box<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 ;
  abs@1{parents={}}{regions={1}} {
    ⌊shared@2⌋,
    @shared_loan({3}, proj_comp {} (s@5 : i32), proj_loans (s@5 : i32))
  }
}



[Debug] drop_value: place: b
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 ;
}



[Debug] test_function_symbolic: copy_int
[Debug] 
**About to evaluate statement**: [
  var@0 := copy x;
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@0 := copy x
]

**Context**:
# 1 frame(s)

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



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

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


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : i32)
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> proj_comp {} (s@0 : i32) ;
  x -> proj_comp {} (s@0 : i32) ;
}



[Debug] test_function_symbolic: test_copy_int
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  px := &x
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := copy x
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := move copy_int(move var@4)
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 1 frame(s)

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



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

**Context**:
# 1 frame(s)

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



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> proj_comp {} (s@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] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@8 := copy y
]

**Context**:
# 1 frame(s)

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



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> @shared_loan({0}, 0: i32) ;
  px -> ⌊shared@0⌋ ;
  y -> proj_comp {} (s@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:
proj_comp {} (s@0 : i32)
[Debug] 
**About to evaluate statement**: [
  var@6 := move var@7 == move var@8;
  var@5 := ¬ move var@6;
  assert(¬move var@5);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@6 := move var@7 == move var@8
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@8

[Debug] Value to move:
proj_comp {} (s@0 : i32)
[Debug] 
**About to evaluate statement**: [
  var@5 := ¬ move var@6;
  assert(¬move var@5);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@5 := ¬ move var@6
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@6

[Debug] Value to move:
proj_comp {} (s@1 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@5);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@5)
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@5

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

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



[Debug] test_function_symbolic: is_cons
[Debug] 
**About to evaluate statement**: [
  var@2 := discriminant(*(l));
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  };
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 (test1::List<T>))
  }
  var@0 -> ⊥ : bool ;
  l -> proj_comp {} (s@0 : &r@0 (test1::List<T>)) ;
  var@2 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := discriminant(*(l))
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 (test1::List<T>))
  }
  var@0 -> ⊥ : bool ;
  l -> proj_comp {} (s@0 : &r@0 (test1::List<T>)) ;
  var@2 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  };
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Cons { 0 = proj_comp {} (s@2 : T); 1 = proj_comp {} (s@3 : std::boxed::Box<test1::List<T>>); }, test1::List::Cons { 0 = proj_loans (s@2 : T); 1 = proj_loans (s@3 : std::boxed::Box<test1::List<T>>); })
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> 0: isize ;
}



[Debug] 
**About to evaluate statement**: [
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Cons { 0 = proj_comp {} (s@2 : T); 1 = proj_comp {} (s@3 : std::boxed::Box<test1::List<T>>); }, test1::List::Cons { 0 = proj_loans (s@2 : T); 1 = proj_loans (s@3 : std::boxed::Box<test1::List<T>>); })
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> 0: isize ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Cons { 0 = proj_comp {} (s@2 : T); 1 = proj_comp {} (s@3 : std::boxed::Box<test1::List<T>>); }, test1::List::Cons { 0 = proj_loans (s@2 : T); 1 = proj_loans (s@3 : std::boxed::Box<test1::List<T>>); })
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> 0: isize ;
}


- op:
move var@2

[Debug] Value to move:
0: isize
[Debug] 
**About to evaluate statement**: [
  var@0 := true
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Cons { 0 = proj_comp {} (s@2 : T); 1 = proj_comp {} (s@3 : std::boxed::Box<test1::List<T>>); }, test1::List::Cons { 0 = proj_loans (s@2 : T); 1 = proj_loans (s@3 : std::boxed::Box<test1::List<T>>); })
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> ⊥ : isize ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Cons { 0 = proj_comp {} (s@2 : T); 1 = proj_comp {} (s@3 : std::boxed::Box<test1::List<T>>); }, test1::List::Cons { 0 = proj_loans (s@2 : T); 1 = proj_loans (s@3 : std::boxed::Box<test1::List<T>>); })
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> ⊥ : isize ;
}


- op:
true

[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Cons { 0 = proj_comp {} (s@2 : T); 1 = proj_comp {} (s@3 : std::boxed::Box<test1::List<T>>); }, test1::List::Cons { 0 = proj_loans (s@2 : T); 1 = proj_loans (s@3 : std::boxed::Box<test1::List<T>>); })
  }
  var@0 -> true ;
  l -> ⌊shared@0⌋ ;
  var@2 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  };
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Nil, test1::List::Nil)
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> 1: isize ;
}



[Debug] 
**About to evaluate statement**: [
  switch (move var@2) {
    0: isize => {
      var@0 := true
    }
    1: isize => {
      var@0 := false
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Nil, test1::List::Nil)
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> 1: isize ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Nil, test1::List::Nil)
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> 1: isize ;
}


- op:
move var@2

[Debug] Value to move:
1: isize
[Debug] 
**About to evaluate statement**: [
  var@0 := false
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Nil, test1::List::Nil)
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> ⊥ : isize ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Nil, test1::List::Nil)
  }
  var@0 -> ⊥ : bool ;
  l -> ⌊shared@0⌋ ;
  var@2 -> ⊥ : isize ;
}


- op:
false

[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    @shared_loan({0}, test1::List::Nil, test1::List::Nil)
  }
  var@0 -> false ;
  l -> ⌊shared@0⌋ ;
  var@2 -> ⊥ : isize ;
}



[Debug] test_function_symbolic: test_is_cons
[Debug] 
**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
]

**Context**:
# 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>) ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(var@3, 1)
]

**Context**:
# 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>) ;
}



[Debug] 
**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
]

**Context**:
# 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>) ;
}



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

**Context**:
# 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>) ;
}



[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] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> proj_comp {} (s@0 : 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] 
**About to evaluate statement**: [
  (l as test1::List::Cons).0 := 0: i32
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> proj_comp {} (s@0 : 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] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> proj_comp {} (s@0 : 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>) ;
}


- 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] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> proj_comp {} (s@0 : 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] 
**About to evaluate statement**: [
  (l as test1::List::Cons).1 := move var@2
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> proj_comp {} (s@0 : 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] 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 -> proj_comp {} (s@0 : 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>) ;
}


- op:
move var@2

[Debug] Value to move:
proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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>) ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(l, 0)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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>) ;
}



[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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>) ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := &l
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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>) ;
}



[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 -> ⌊shared@0⌋ ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := copy var@7
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 -> ⌊shared@0⌋ ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 -> ⌊shared@0⌋ ;
}


- op:
copy var@7

[Debug] Value to copy:
⌊shared@0⌋
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  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⌋ ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := move is_cons<i32>(move var@6)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  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⌋ ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  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] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5;
  assert(¬move var@4);
  drop(l);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> proj_comp {} (s@1 : bool) ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}



[Debug] 
**About to evaluate statement**: [
  var@4 := ¬ move var@5
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> proj_comp {} (s@1 : bool) ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> ⊥ : bool ;
  var@5 -> proj_comp {} (s@1 : bool) ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}


- op:
move var@5

[Debug] Value to move:
proj_comp {} (s@1 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@4);
  drop(l);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> proj_comp {} (s@2 : bool) ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@4)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> proj_comp {} (s@2 : bool) ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }) ;
  var@2 -> ⊥ : std::boxed::Box<test1::List<i32>> ;
  var@3 -> ⊥ : test1::List<i32> ;
  var@4 -> true ;
  var@5 -> ⊥ : bool ;
  var@6 -> ⊥ : &'_ (test1::List<i32>) ;
  var@7 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}


- op:
move var@4

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  drop(l);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}



[Debug] 
**About to evaluate statement**: [
  drop(l)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> @shared_loan({0, 1}, test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 -> ⌊shared@0⌋ ;
  abs@0{parents={}}{regions={0}} {
    ⌊shared@1⌋,
    proj_loans (s@1 : bool)
  }
}



[Debug] drop_value: place: l
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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>) ;
}



[Debug] test_function_symbolic: split_list
[Debug] 
**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<T>>(move tl);
      return
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := false
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 ;
}


- op:
false

[Debug] 
**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<T>>(move tl);
      return
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := false
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
false

[Debug] 
**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<T>>(move tl);
      return
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := true
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
true

[Debug] 
**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<T>>(move tl);
      return
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := true
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
true

[Debug] 
**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<T>>(move tl);
      return
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := discriminant(l)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> proj_comp {} (s@0 : 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 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**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<T>>(move tl);
      return
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> 0: isize ;
  hd -> ⊥ : T ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> 0: isize ;
  hd -> ⊥ : T ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@2

[Debug] Value to move:
0: isize
[Debug] 
**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<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<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 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := false
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<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 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<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 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
false

[Debug] 
**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<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<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 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  hd := move (l as test1::List::Cons).0
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<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 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = proj_comp {} (s@1 : T); 1 = proj_comp {} (s@2 : std::boxed::Box<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 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move (l as test1::List::Cons).0

[Debug] Value to move:
proj_comp {} (s@1 : T)
[Debug] 
**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<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := false
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
false

[Debug] 
**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<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  tl := move (l as test1::List::Cons).1
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>); } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move (l as test1::List::Cons).1

[Debug] Value to move:
proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>)
[Debug] 
**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<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>) ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := move hd
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>) ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> proj_comp {} (s@1 : T) ;
  tl -> proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>) ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move hd

[Debug] Value to move:
proj_comp {} (s@1 : T)
[Debug] 
**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<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>) ;
  var@5 -> proj_comp {} (s@1 : T) ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := move deref_box(tl)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>) ;
  var@5 -> proj_comp {} (s@1 : T) ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> proj_comp {} (s@2 : std::boxed::Box<test1::List<T>>) ;
  var@5 -> proj_comp {} (s@1 : T) ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move deref_box(tl)

[Debug] Value to move:
proj_comp {} (s@3 : test1::List<T>)
[Debug] 
**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<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> proj_comp {} (s@1 : T) ;
  var@6 -> proj_comp {} (s@3 : test1::List<T>) ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  (var@0).0 := move var@5
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> proj_comp {} (s@1 : T) ;
  var@6 -> proj_comp {} (s@3 : test1::List<T>) ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> proj_comp {} (s@1 : T) ;
  var@6 -> proj_comp {} (s@3 : test1::List<T>) ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@5

[Debug] Value to move:
proj_comp {} (s@1 : T)
[Debug] expand_bottom_value_from_projection:
pe: (Expressions.Field ((Expressions.ProjTuple 2), 0))
ty: (Types.Adt (Types.Tuple, [],
   [(Types.TypeVar 0); (Types.Adt ((Types.AdtId 1), [], [(Types.TypeVar 0)]))
     ]
   ))
[Debug] 
**About to evaluate statement**: [
  (var@0).1 := move var@6;
  var@9 := move alloc::alloc::box_free<test1::List<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> (proj_comp {} (s@1 : T), ⊥ : test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> ⊥ : T ;
  var@6 -> proj_comp {} (s@3 : test1::List<T>) ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  (var@0).1 := move var@6
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> (proj_comp {} (s@1 : T), ⊥ : test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> ⊥ : T ;
  var@6 -> proj_comp {} (s@3 : test1::List<T>) ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> (proj_comp {} (s@1 : T), ⊥ : test1::List<T>) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> ⊥ : T ;
  var@6 -> proj_comp {} (s@3 : test1::List<T>) ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@6

[Debug] Value to move:
proj_comp {} (s@3 : test1::List<T>)
[Debug] 
**About to evaluate statement**: [
  var@9 := move alloc::alloc::box_free<test1::List<T>>(move tl);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> (proj_comp {} (s@1 : T), proj_comp {} (s@3 : test1::List<T>)) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**About to evaluate statement**: [
  var@9 := move alloc::alloc::box_free<test1::List<T>>(move tl)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> (proj_comp {} (s@1 : T), proj_comp {} (s@3 : test1::List<T>)) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<test1::List<T>>; } ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> @Box(⊥ : test1::List<T>) ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> false ;
  var@8 -> false ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] eval_non_local_function_call:
- fid:CfimAst.BoxFree
- type_params: [test1::List<T>]
- args: [move tl]
- dest: var@9
[Debug] drop_value: place: tl
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> (proj_comp {} (s@1 : T), proj_comp {} (s@3 : test1::List<T>)) ;
  l -> test1::List::Cons { 0 = ⊥ : T; 1 = ⊥ : std::boxed::Box<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 -> false ;
  var@8 -> false ;
  var@9 -> () ;
  var@10 -> ⊥ : isize ;
}



[Debug] 
**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<T>>(move tl);
      return
    }
    _ => {
      panic
    }
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Nil ;
  var@2 -> 1: isize ;
  hd -> ⊥ : T ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Nil ;
  var@2 -> 1: isize ;
  hd -> ⊥ : T ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}


- op:
move var@2

[Debug] Value to move:
1: isize
[Debug] 
**About to evaluate statement**: [
  panic
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : (T, test1::List<T>) ;
  l -> test1::List::Nil ;
  var@2 -> ⊥ : isize ;
  hd -> ⊥ : T ;
  tl -> ⊥ : std::boxed::Box<test1::List<T>> ;
  var@5 -> ⊥ : T ;
  var@6 -> ⊥ : test1::List<T> ;
  var@7 -> true ;
  var@8 -> true ;
  var@9 -> ⊥ : () ;
  var@10 -> ⊥ : isize ;
}



[Debug] test_function_symbolic: test_split_list
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(var@3, 1)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



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

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> proj_comp {} (s@0 : 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 ;
}



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

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> proj_comp {} (s@0 : 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 ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> ⊥ : test1::List<i32> ;
  var@2 -> proj_comp {} (s@0 : 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:
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] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> proj_comp {} (s@0 : 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 ;
}



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

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = ⊥ : std::boxed::Box<test1::List<i32>>; } ;
  var@2 -> proj_comp {} (s@0 : 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 ;
}



[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 -> proj_comp {} (s@0 : 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 var@2

[Debug] Value to move:
proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 ;
}



[Debug] 
**About to evaluate statement**: [
  set_discriminant(l, 0)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 ;
}



[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := move l
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  l -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<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 ;
}


- op:
move l

[Debug] Value to move:
test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }
[Debug] 
**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
]

**Context**:
# 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 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); } ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := move split_list<i32>(move var@7)
]

**Context**:
# 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 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); } ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : 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 -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> ⊥ : (i32, test1::List<i32>) ;
  var@7 -> test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); } ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@7

[Debug] Value to move:
test1::List::Cons { 0 = 0: i32; 1 = proj_comp {} (s@0 : std::boxed::Box<test1::List<i32>>); }
[Debug] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@1 : (i32, test1::List<i32>)) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  hd := copy (var@6).0
]

**Context**:
# 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 -> proj_comp {} (s@1 : (i32, test1::List<i32>)) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : 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 -> ⊥ : i32 ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> proj_comp {} (s@1 : (i32, test1::List<i32>)) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
copy (var@6).0

[Debug] Value to copy:
proj_comp {} (s@2 : i32)
[Debug] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (proj_comp {} (s@2 : i32), proj_comp {} (s@3 : test1::List<i32>)) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  tl := move (var@6).1
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (proj_comp {} (s@2 : i32), proj_comp {} (s@3 : test1::List<i32>)) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : 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 -> proj_comp {} (s@2 : i32) ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (proj_comp {} (s@2 : i32), proj_comp {} (s@3 : test1::List<i32>)) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move (var@6).1

[Debug] Value to move:
proj_comp {} (s@3 : test1::List<i32>)
[Debug] 
**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
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  var@10 := copy hd
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : 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:
proj_comp {} (s@2 : i32)
[Debug] 
**About to evaluate statement**: [
  var@9 := move var@10 == 0: i32;
  var@8 := ¬ move var@9;
  assert(¬move var@8);
  drop(tl);
  return
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> proj_comp {} (s@2 : i32) ;
}



[Debug] 
**About to evaluate statement**: [
  var@9 := move var@10 == 0: i32
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> proj_comp {} (s@2 : 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> proj_comp {} (s@2 : i32) ;
}


- op:
move var@10

[Debug] Value to move:
proj_comp {} (s@2 : 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
0: i32

[Debug] 
**About to evaluate statement**: [
  var@8 := ¬ move var@9;
  assert(¬move var@8);
  drop(tl);
  return
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> proj_comp {} (s@4 : bool) ;
  var@10 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  var@8 := ¬ move var@9
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> proj_comp {} (s@4 : bool) ;
  var@10 -> ⊥ : 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> proj_comp {} (s@4 : bool) ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@9

[Debug] Value to move:
proj_comp {} (s@4 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@8);
  drop(tl);
  return
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> proj_comp {} (s@5 : bool) ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@8)
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> proj_comp {} (s@5 : bool) ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> true ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}


- op:
move var@8

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  drop(tl);
  return
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] 
**About to evaluate statement**: [
  drop(tl)
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> proj_comp {} (s@3 : test1::List<i32>) ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] drop_value: place: tl
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 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 -> proj_comp {} (s@2 : i32) ;
  tl -> ⊥ : test1::List<i32> ;
  var@6 -> (proj_comp {} (s@2 : i32), ⊥ : test1::List<i32>) ;
  var@7 -> ⊥ : test1::List<i32> ;
  var@8 -> ⊥ : bool ;
  var@9 -> ⊥ : bool ;
  var@10 -> ⊥ : i32 ;
}



[Debug] test_function_symbolic: get_elem
[Debug] 
**About to evaluate statement**: [
  var@4 := copy b;
  if (move var@4) {
    var@0 := &mut *(x)
  }
  else {
    var@0 := move y
  };
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : bool),
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> proj_comp {} (s@0 : bool) ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> ⊥ : bool ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := copy b
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : bool),
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> proj_comp {} (s@0 : bool) ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> ⊥ : bool ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : bool),
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> proj_comp {} (s@0 : bool) ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> ⊥ : bool ;
}


- op:
copy b

[Debug] Value to copy:
proj_comp {} (s@0 : bool)
[Debug] 
**About to evaluate statement**: [
  if (move var@4) {
    var@0 := &mut *(x)
  }
  else {
    var@0 := move y
  };
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : bool),
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> proj_comp {} (s@0 : bool) ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> proj_comp {} (s@0 : bool) ;
}



[Debug] 
**About to evaluate statement**: [
  if (move var@4) {
    var@0 := &mut *(x)
  }
  else {
    var@0 := move y
  }
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : bool),
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> proj_comp {} (s@0 : bool) ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> proj_comp {} (s@0 : bool) ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    true,
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> true ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> true ;
}


- op:
move var@4

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(x)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    true,
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> true ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> ⊥ : bool ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    false,
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> false ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> false ;
}


- op:
move var@4

[Debug] Value to move:
false
[Debug] 
**About to evaluate statement**: [
  var@0 := move y
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    false,
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> false ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> ⊥ : bool ;
}



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

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    false,
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> ⊥ : &'_ mut (T) ;
  b -> false ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> ⊥ : bool ;
}


- op:
move y

[Debug] Value to move:
proj_comp {} (s@2 : &r@0 mut (T))
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    true,
    ⌊mut@0, proj_loans (s@3 : T)⌋,
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> &mut@1 (proj_comp {} (s@3 : T)) ;
  b -> true ;
  x -> &mut@0 (⌊mut@1⌋) ;
  y -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  var@4 -> ⊥ : bool ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    false,
    proj_loans (s@1 : &r@0 mut (T)),
    proj_loans (s@2 : &r@0 mut (T))
  }
  var@0 -> proj_comp {} (s@2 : &r@0 mut (T)) ;
  b -> false ;
  x -> proj_comp {} (s@1 : &r@0 mut (T)) ;
  y -> ⊥ : &'_ mut (T) ;
  var@4 -> ⊥ : bool ;
}



[Debug] test_function_symbolic: get_elem_test
[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  y := 0: i32
]

**Context**:
# 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 ;
}



[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] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@5 := &mut x
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := &two-phase *(var@5)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := &mut y
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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 ;
}



[Debug] 
**About to evaluate statement**: [
  var@6 := &two-phase *(var@7)
]

**Context**:
# 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 ;
}



[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  z := move get_elem<i32>(true, move var@4, move var@6)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
true

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

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


- op:
move var@4

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Concrete (Values.Scalar { Values.value = 0; int_ty = Types.I32 }));
  ty = (Types.Integer Types.I32) }
[Debug] Value to move:
&mut@1 (0: i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
move var@6

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Concrete (Values.Scalar { Values.value = 0; int_ty = Types.I32 }));
  ty = (Types.Integer Types.I32) }
[Debug] Value to move:
&mut@3 (0: i32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> proj_comp {} (s@0 : &r@0 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 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    proj_loans (s@0 : &r@0 mut (i32))
  }
}



[Debug] 
**About to evaluate statement**: [
  var@8 := copy *(z)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> proj_comp {} (s@0 : &r@0 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 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    proj_loans (s@0 : &r@0 mut (i32))
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> proj_comp {} (s@0 : &r@0 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 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    proj_loans (s@0 : &r@0 mut (i32))
  }
}


- op:
copy *(z)

[Debug] Value to copy:
proj_comp {} (s@1 : i32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@1 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  *(z) := copy var@8 + 1: i32
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@1 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@1 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
copy var@8

[Debug] Value to copy:
proj_comp {} (s@1 : i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@1 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
1: i32

[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  var@12 := copy *(z)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
copy *(z)

[Debug] Value to copy:
proj_comp {} (s@2 : i32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> proj_comp {} (s@2 : i32) ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  var@11 := move var@12 == 1: i32
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> proj_comp {} (s@2 : i32) ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> proj_comp {} (s@2 : i32) ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
move var@12

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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
1: i32

[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> proj_comp {} (s@3 : bool) ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  var@10 := ¬ move var@11
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> proj_comp {} (s@3 : bool) ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> proj_comp {} (s@3 : bool) ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
move var@11

[Debug] Value to move:
proj_comp {} (s@3 : bool)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> proj_comp {} (s@4 : bool) ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@10)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> proj_comp {} (s@4 : bool) ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> true ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
move var@10

[Debug] Value to move:
true
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  var@15 := copy x
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  y -> ⌊mut@2⌋ ;
  z -> &mut@4 (proj_comp {} (s@2 : i32)) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> &mut@0 (⌊mut@1⌋) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (⌊mut@3⌋) ;
  var@8 -> proj_comp {} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> ⊥ : bool ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
  abs@0{parents={}}{regions={0}} {
    true,
    &mut@1 (0: i32),
    &mut@3 (0: i32),
    ⌊mut@4, proj_loans (s@1 : i32)⌋
  }
}


- op:
copy x

[Debug] Value to copy:
proj_comp {0} (s@5 : i32)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@14 := move var@15 == 1: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@15

[Debug] Value to move:
proj_comp {0} (s@5 : i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {0} (s@5 : i32) ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (proj_comp {0} (s@6 : i32)) ;
  var@8 -> proj_comp {0} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  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] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@13 := ¬ move var@14
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@14

[Debug] Value to move:
proj_comp {} (s@7 : bool)
[Debug] 
**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
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@13)
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@13

[Debug] Value to move:
true
[Debug] 
**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
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {0} (s@5 : i32) ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (proj_comp {0} (s@6 : i32)) ;
  var@8 -> proj_comp {0} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  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] 
**About to evaluate statement**: [
  var@18 := copy y
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {0} (s@5 : i32) ;
  y -> ⌊mut@2⌋ ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> &mut@2 (proj_comp {0} (s@6 : i32)) ;
  var@8 -> proj_comp {0} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  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] eval_operand:
- ctx:
# 1 frame(s)

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


- op:
copy y

[Debug] Value to copy:
proj_comp {0} (s@6 : i32)
[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 0: i32;
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@17 := move var@18 == 0: i32
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@18

[Debug] Value to move:
proj_comp {0} (s@6 : i32)
[Debug] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {0} (s@5 : i32) ;
  y -> proj_comp {0} (s@6 : i32) ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> proj_comp {0} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  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] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17;
  assert(¬move var@16);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  var@16 := ¬ move var@17
]

**Context**:
# 1 frame(s)

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



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

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


- op:
move var@17

[Debug] Value to move:
proj_comp {} (s@9 : bool)
[Debug] 
**About to evaluate statement**: [
  assert(¬move var@16);
  return
]

**Context**:
# 1 frame(s)

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



[Debug] 
**About to evaluate statement**: [
  assert(¬move var@16)
]

**Context**:
# 1 frame(s)

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



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

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {0} (s@5 : i32) ;
  y -> proj_comp {0} (s@6 : i32) ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> proj_comp {0} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  var@11 -> ⊥ : bool ;
  var@12 -> ⊥ : i32 ;
  var@13 -> ⊥ : bool ;
  var@14 -> ⊥ : bool ;
  var@15 -> ⊥ : i32 ;
  var@16 -> true ;
  var@17 -> ⊥ : bool ;
  var@18 -> ⊥ : i32 ;
}


- op:
move var@16

[Debug] Value to move:
true
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> proj_comp {0} (s@5 : i32) ;
  y -> proj_comp {0} (s@6 : i32) ;
  z -> ⊥ : &'_ mut (i32) ;
  var@4 -> ⊥ : &'_ mut (i32) ;
  var@5 -> ⊥ : &'_ mut (i32) ;
  var@6 -> ⊥ : &'_ mut (i32) ;
  var@7 -> ⊥ : &'_ mut (i32) ;
  var@8 -> proj_comp {0} (s@1 : i32) ;
  var@9 -> ⊥ : (i32, bool) ;
  var@10 -> ⊥ : bool ;
  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] test_function_symbolic: id_mut_mut
[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x);
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut (&r@1 mut (T)))
  }
  abs@1{parents={0}}{regions={1}} {
    proj_loans (s@0 : &r@0 mut (&r@1 mut (T)))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (T)) ;
  x -> proj_comp {} (s@0 : &r@0 mut (&r@1 mut (T))) ;
  var@2 -> ⊥ : &'_ mut (&'_ mut (T)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut (&r@1 mut (T)))
  }
  abs@1{parents={0}}{regions={1}} {
    proj_loans (s@0 : &r@0 mut (&r@1 mut (T)))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (T)) ;
  x -> proj_comp {} (s@0 : &r@0 mut (&r@1 mut (T))) ;
  var@2 -> ⊥ : &'_ mut (&'_ mut (T)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@1 mut (T))⌋
  }
  abs@1{parents={0}}{regions={1}} {
    @ignored_mut_loan(0, proj_loans (s@1 : &r@1 mut (T)))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (T)) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : &r@1 mut (T))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@1 mut (T))⌋
  }
  abs@1{parents={0}}{regions={1}} {
    @ignored_mut_loan(0, proj_loans (s@1 : &r@1 mut (T)))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (T)) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : &r@1 mut (T))) ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@1 mut (T))⌋
  }
  abs@1{parents={0}}{regions={1}} {
    @ignored_mut_loan(0, proj_loans (s@1 : &r@1 mut (T)))
  }
  var@0 -> &mut@2 (proj_comp {} (s@1 : &r@1 mut (T))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (⌊mut@2⌋) ;
}



[Debug] test_function_symbolic: id_mut_pair
[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x);
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (T), u32)))
  }
  var@0 -> ⊥ : &'_ mut ((&'_ mut (T), u32)) ;
  x -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (T), u32))) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (T), u32)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (T), u32)))
  }
  var@0 -> ⊥ : &'_ mut ((&'_ mut (T), u32)) ;
  x -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (T), u32))) ;
  var@2 -> ⊥ : &'_ mut ((&'_ mut (T), u32)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : (&r@0 mut (T), u32))⌋
  }
  var@0 -> ⊥ : &'_ mut ((&'_ mut (T), u32)) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : (&r@0 mut (T), u32))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : (&r@0 mut (T), u32))⌋
  }
  var@0 -> ⊥ : &'_ mut ((&'_ mut (T), u32)) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : (&r@0 mut (T), u32))) ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : (&r@0 mut (T), u32))⌋
  }
  var@0 -> &mut@2 (proj_comp {} (s@1 : (&r@0 mut (T), u32))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (⌊mut@2⌋) ;
}



[Debug] test_function_symbolic: id_mut_pair_test1
[Debug] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  x := 0: u32
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  px := &mut x
]

**Context**:
# 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) ;
}



[Debug] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  var@4 := move px
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  (p).0 := move var@4
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  (p).1 := 1: u32
]

**Context**:
# 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) ;
}



[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] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  pp0 := &mut p
]

**Context**:
# 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) ;
}



[Debug] 
**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
]

**Context**:
# 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) ;
}



[Debug] 
**About to evaluate statement**: [
  var@7 := &two-phase *(pp0)
]

**Context**:
# 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) ;
}



[Debug] 
**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
]

**Context**:
# 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] 
**About to evaluate statement**: [
  pp1 := move id_mut_pair<u32>(move var@7)
]

**Context**:
# 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] eval_operand:
- ctx:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : () ;
  x -> ⌊mut@0⌋ ;
  px -> ⊥ : &'_ mut (u32) ;
  p -> ⌊mut@1⌋ ;
  var@4 -> ⊥ : &'_ mut (u32) ;
  pp0 -> &mut@1 (@shared_loan({2}, (&mut@0 (0: u32), 1: u32))) ;
  pp1 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  var@7 -> ⌊inactivated_mut@2⌋ ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
}


- op:
move var@7

[Debug] activate_inactivated_mut_borrow: resulting value:
{ Values.value =
  (Values.Adt
     { Values.variant_id = <opaque>;
       field_values =
       [{ Values.value =
          (Values.Borrow
             (Values.MutBorrow (<opaque>,
                { Values.value =
                  (Values.Concrete
                     (Values.Scalar { Values.value = 0; int_ty = Types.U32 }));
                  ty = (Types.Integer Types.U32) }
                )));
          ty =
          (Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut)) };
         { Values.value =
           (Values.Concrete
              (Values.Scalar { Values.value = 1; int_ty = Types.U32 }));
           ty = (Types.Integer Types.U32) }
         ]
       });
  ty =
  (Types.Adt (Types.Tuple, [],
     [(Types.Ref (Types.Erased, (Types.Integer Types.U32), Types.Mut));
       (Types.Integer Types.U32)]
     ))
  }
[Debug] Value to move:
&mut@2 ((&mut@0 (0: u32), 1: u32))
[Debug] 
**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
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}



[Debug] 
**About to evaluate statement**: [
  y := 2: u32
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), 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@2⌋) ;
  pp1 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⊥ : u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}


- op:
2: u32

[Debug] 
**About to evaluate statement**: [
  var@10 := &mut y;
  var@9 := &mut *(var@10);
  *((pp1).0) := move var@9;
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> 2: u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}



[Debug] 
**About to evaluate statement**: [
  var@10 := &mut y
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> 2: u32 ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> ⊥ : &'_ mut (u32) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}



[Debug] 
**About to evaluate statement**: [
  var@9 := &mut *(var@10);
  *((pp1).0) := move var@9;
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@3 (2: u32) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}



[Debug] 
**About to evaluate statement**: [
  var@9 := &mut *(var@10)
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@3 (2: u32) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}



[Debug] 
**About to evaluate statement**: [
  *((pp1).0) := move var@9;
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> &mut@4 (2: u32) ;
  var@10 -> &mut@3 (⌊mut@4⌋) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}



[Debug] 
**About to evaluate statement**: [
  *((pp1).0) := move var@9
]

**Context**:
# 1 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 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> &mut@4 (2: u32) ;
  var@10 -> &mut@3 (⌊mut@4⌋) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), 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@2⌋) ;
  pp1 -> proj_comp {} (s@0 : &r@0 mut ((&r@0 mut (u32), u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> &mut@4 (2: u32) ;
  var@10 -> &mut@3 (⌊mut@4⌋) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    proj_loans (s@0 : &r@0 mut ((&r@0 mut (u32), u32)))
  }
}


- op:
move var@9

[Debug] Value to move:
&mut@4 (2: u32)
[Debug] 
**About to evaluate statement**: [
  *((pp1).1) := 3: u32;
  return
]

**Context**:
# 1 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@5 ((&mut@4 (2: u32), proj_comp {} (s@3 : u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@3 (⌊mut@4⌋) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    ⌊mut@5, (proj_loans (s@2 : &r@0 mut (u32)), proj_loans (s@3 : u32))⌋
  }
}



[Debug] 
**About to evaluate statement**: [
  *((pp1).1) := 3: u32
]

**Context**:
# 1 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@5 ((&mut@4 (2: u32), proj_comp {} (s@3 : u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@3 (⌊mut@4⌋) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    ⌊mut@5, (proj_loans (s@2 : &r@0 mut (u32)), proj_loans (s@3 : 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@2⌋) ;
  pp1 -> &mut@5 ((&mut@4 (2: u32), proj_comp {} (s@3 : u32))) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@3 (⌊mut@4⌋) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    ⌊mut@5, (proj_loans (s@2 : &r@0 mut (u32)), proj_loans (s@3 : u32))⌋
  }
}


- op:
3: u32

[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 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@5 ((&mut@4 (2: u32), 3: u32)) ;
  var@7 -> ⊥ : &'_ mut ((&'_ mut (u32), u32)) ;
  y -> ⌊mut@3⌋ ;
  var@9 -> ⊥ : &'_ mut (u32) ;
  var@10 -> &mut@3 (⌊mut@4⌋) ;
  abs@0{parents={}}{regions={0}} {
    &mut@2 ((&mut@0 (0: u32), 1: u32)),
    ⌊mut@5, (proj_loans (s@2 : &r@0 mut (u32)), proj_loans (s@3 : u32))⌋
  }
}



[Debug] test_function_symbolic: id_mut_mut_pair
[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x);
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut (&r@0 mut ((&r@0 mut (T), u32))))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut ((&'_ mut (T), u32))) ;
  x -> proj_comp {} (s@0 : &r@0 mut (&r@0 mut ((&r@0 mut (T), u32)))) ;
  var@2 -> ⊥ : &'_ mut (&'_ mut ((&'_ mut (T), u32))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut (&r@0 mut ((&r@0 mut (T), u32))))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut ((&'_ mut (T), u32))) ;
  x -> proj_comp {} (s@0 : &r@0 mut (&r@0 mut ((&r@0 mut (T), u32)))) ;
  var@2 -> ⊥ : &'_ mut (&'_ mut ((&'_ mut (T), u32))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@0 mut ((&r@0 mut (T), u32)))⌋
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut ((&'_ mut (T), u32))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : &r@0 mut ((&r@0 mut (T), u32)))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@0 mut ((&r@0 mut (T), u32)))⌋
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut ((&'_ mut (T), u32))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : &r@0 mut ((&r@0 mut (T), u32)))) ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@0 mut ((&r@0 mut (T), u32)))⌋
  }
  var@0 -> &mut@2 (proj_comp {} (s@1 : &r@0 mut ((&r@0 mut (T), u32)))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (⌊mut@2⌋) ;
}



[Debug] test_function_symbolic: id_mut_mut_mut_same
[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x);
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut (&r@0 mut (&r@0 mut (u32))))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (&'_ mut (u32))) ;
  x -> proj_comp {} (s@0 : &r@0 mut (&r@0 mut (&r@0 mut (u32)))) ;
  var@2 -> ⊥ : &'_ mut (&'_ mut (&'_ mut (u32))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@2 := &mut *(x)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut (&r@0 mut (&r@0 mut (u32))))
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (&'_ mut (u32))) ;
  x -> proj_comp {} (s@0 : &r@0 mut (&r@0 mut (&r@0 mut (u32)))) ;
  var@2 -> ⊥ : &'_ mut (&'_ mut (&'_ mut (u32))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2);
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@0 mut (&r@0 mut (u32)))⌋
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (&'_ mut (u32))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : &r@0 mut (&r@0 mut (u32)))) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := &mut *(var@2)
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@0 mut (&r@0 mut (u32)))⌋
  }
  var@0 -> ⊥ : &'_ mut (&'_ mut (&'_ mut (u32))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (proj_comp {} (s@1 : &r@0 mut (&r@0 mut (u32)))) ;
}



[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    ⌊mut@0, proj_loans (s@1 : &r@0 mut (&r@0 mut (u32)))⌋
  }
  var@0 -> &mut@2 (proj_comp {} (s@1 : &r@0 mut (&r@0 mut (u32)))) ;
  x -> &mut@0 (⌊mut@1⌋) ;
  var@2 -> &mut@1 (⌊mut@2⌋) ;
}



[Debug] test_function_symbolic: id_borrow1
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  abs@0{parents={}}{regions={0}} {
    proj_loans (s@0 : &r@0 mut (&r@1 (u32))),
    proj_loans (s@1 : &r@0 (&r@0 mut (u32)))
  }
  abs@1{parents={0}}{regions={1}} {
    proj_loans (s@0 : &r@0 mut (&r@1 (u32))),
    proj_loans (s@1 : &r@0 (&r@0 mut (u32)))
  }
  var@0 -> ⊥ : () ;
  _x -> proj_comp {} (s@0 : &r@0 mut (&r@1 (u32))) ;
  _y -> proj_comp {} (s@1 : &r@0 (&r@0 mut (u32))) ;
}



[Debug] test_function_symbolic: test_static
[Debug] 
**About to evaluate statement**: [
  var@0 := copy x;
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : &'_ (u32) ;
  x -> proj_comp {} (s@0 : &'static (u32)) ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := copy x
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : &'_ (u32) ;
  x -> proj_comp {} (s@0 : &'static (u32)) ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : &'_ (u32) ;
  x -> proj_comp {} (s@0 : &'static (u32)) ;
}


- op:
copy x

[Debug] Value to copy:
proj_comp {} (s@0 : &'static (u32))
[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> proj_comp {} (s@0 : &'static (u32)) ;
  x -> proj_comp {} (s@0 : &'static (u32)) ;
}



[Debug] test_function_symbolic: test_char
[Debug] 
**About to evaluate statement**: [
  var@0 := a;
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : char ;
}



[Debug] 
**About to evaluate statement**: [
  var@0 := a
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> ⊥ : char ;
}



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

# Frame 0:
{
  var@0 -> ⊥ : char ;
}


- op:
a

[Debug] 
**About to evaluate statement**: [
  return
]

**Context**:
# 1 frame(s)

# Frame 0:
{
  var@0 -> a ;
}