Regenerate the Coq test files

24 files changed, 3589 insertions, 2118 deletions

diff --git a/backends/coq/Primitives.v b/backends/coq/Primitives.v
index 8e0e973d..85e38f01 100644
--- a/backends/coq/Primitives.v
+++ b/backends/coq/Primitives.v
@@ -499,7 +499,7 @@ Qed.
 Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
 
 (* For initialization *)
-Axiom array_repeat : forall {T : Type} (n : usize) (x : T), array T n.
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
 
 Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
 Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
diff --git a/tests/coq/array/Array_Funs.v b/tests/coq/array/Array_Funs.v
index 6ff3066a..9980a6e8 100644
--- a/tests/coq/array/Array_Funs.v
+++ b/tests/coq/array/Array_Funs.v
@@ -10,16 +10,21 @@ Require Export Array_Types.
 Import Array_Types.
 Module Array_Funs.
 
+(** [array::incr]: merged forward/backward function
+    (there is a single backward function, and the forward function returns ()) *)
+Definition incr (x : u32) : result u32 :=
+  u32_add x 1%u32.
+
 (** [array::array_to_shared_slice_]: forward function *)
-Definition array_to_shared_slice__fwd
+Definition array_to_shared_slice_
   (T : Type) (s : array T 32%usize) : result (slice T) :=
-  array_to_slice_shared T 32%usize s
+  array_to_slice T 32%usize s
 .
 
 (** [array::array_to_mut_slice_]: forward function *)
-Definition array_to_mut_slice__fwd
+Definition array_to_mut_slice_
   (T : Type) (s : array T 32%usize) : result (slice T) :=
-  array_to_slice_mut_fwd T 32%usize s
+  array_to_slice T 32%usize s
 .
 
 (** [array::array_to_mut_slice_]: backward function 0 *)
@@ -27,58 +32,44 @@ Definition array_to_mut_slice__back
   (T : Type) (s : array T 32%usize) (ret : slice T) :
   result (array T 32%usize)
   :=
-  array_to_slice_mut_back T 32%usize s ret
+  array_from_slice T 32%usize s ret
 .
 
 (** [array::array_len]: forward function *)
-Definition array_len_fwd (T : Type) (s : array T 32%usize) : result usize :=
-  s0 <- array_to_slice_shared T 32%usize s; let i := slice_len T s0 in Return i
+Definition array_len (T : Type) (s : array T 32%usize) : result usize :=
+  s0 <- array_to_slice T 32%usize s; let i := slice_len T s0 in Return i
 .
 
 (** [array::shared_array_len]: forward function *)
-Definition shared_array_len_fwd
-  (T : Type) (s : array T 32%usize) : result usize :=
-  s0 <- array_to_slice_shared T 32%usize s; let i := slice_len T s0 in Return i
+Definition shared_array_len (T : Type) (s : array T 32%usize) : result usize :=
+  s0 <- array_to_slice T 32%usize s; let i := slice_len T s0 in Return i
 .
 
 (** [array::shared_slice_len]: forward function *)
-Definition shared_slice_len_fwd (T : Type) (s : slice T) : result usize :=
+Definition shared_slice_len (T : Type) (s : slice T) : result usize :=
   let i := slice_len T s in Return i
 .
 
 (** [array::index_array_shared]: forward function *)
-Definition index_array_shared_fwd
+Definition index_array_shared
   (T : Type) (s : array T 32%usize) (i : usize) : result T :=
-  array_index_shared T 32%usize s i
+  array_index_usize T 32%usize s i
 .
 
 (** [array::index_array_u32]: forward function *)
-Definition index_array_u32_fwd
-  (s : array u32 32%usize) (i : usize) : result u32 :=
-  array_index_shared u32 32%usize s i
-.
-
-(** [array::index_array_generic]: forward function *)
-Definition index_array_generic_fwd
-  (N : usize) (s : array u32 N) (i : usize) : result u32 :=
-  array_index_shared u32 N s i
-.
-
-(** [array::index_array_generic_call]: forward function *)
-Definition index_array_generic_call_fwd
-  (N : usize) (s : array u32 N) (i : usize) : result u32 :=
-  index_array_generic_fwd N s i
+Definition index_array_u32 (s : array u32 32%usize) (i : usize) : result u32 :=
+  array_index_usize u32 32%usize s i
 .
 
 (** [array::index_array_copy]: forward function *)
-Definition index_array_copy_fwd (x : array u32 32%usize) : result u32 :=
-  array_index_shared u32 32%usize x 0%usize
+Definition index_array_copy (x : array u32 32%usize) : result u32 :=
+  array_index_usize u32 32%usize x 0%usize
 .
 
 (** [array::index_mut_array]: forward function *)
-Definition index_mut_array_fwd
+Definition index_mut_array
   (T : Type) (s : array T 32%usize) (i : usize) : result T :=
-  array_index_mut_fwd T 32%usize s i
+  array_index_usize T 32%usize s i
 .
 
 (** [array::index_mut_array]: backward function 0 *)
@@ -86,298 +77,314 @@ Definition index_mut_array_back
   (T : Type) (s : array T 32%usize) (i : usize) (ret : T) :
   result (array T 32%usize)
   :=
-  array_index_mut_back T 32%usize s i ret
+  array_update_usize T 32%usize s i ret
 .
 
 (** [array::index_slice]: forward function *)
-Definition index_slice_fwd (T : Type) (s : slice T) (i : usize) : result T :=
-  slice_index_shared T s i
+Definition index_slice (T : Type) (s : slice T) (i : usize) : result T :=
+  slice_index_usize T s i
 .
 
 (** [array::index_mut_slice]: forward function *)
-Definition index_mut_slice_fwd
-  (T : Type) (s : slice T) (i : usize) : result T :=
-  slice_index_mut_fwd T s i
+Definition index_mut_slice (T : Type) (s : slice T) (i : usize) : result T :=
+  slice_index_usize T s i
 .
 
 (** [array::index_mut_slice]: backward function 0 *)
 Definition index_mut_slice_back
   (T : Type) (s : slice T) (i : usize) (ret : T) : result (slice T) :=
-  slice_index_mut_back T s i ret
+  slice_update_usize T s i ret
 .
 
 (** [array::slice_subslice_shared_]: forward function *)
-Definition slice_subslice_shared__fwd
-  (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
-  slice_subslice_shared u32 x (mk_range y z)
+Definition slice_subslice_shared_
+  (n : nat) (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
+  core_slice_index_Slice_index u32 (core_ops_range_Range usize)
+    (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
 (** [array::slice_subslice_mut_]: forward function *)
-Definition slice_subslice_mut__fwd
-  (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
-  slice_subslice_mut_fwd u32 x (mk_range y z)
+Definition slice_subslice_mut_
+  (n : nat) (x : slice u32) (y : usize) (z : usize) : result (slice u32) :=
+  core_slice_index_Slice_index_mut u32 (core_ops_range_Range usize)
+    (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
 (** [array::slice_subslice_mut_]: backward function 0 *)
 Definition slice_subslice_mut__back
-  (x : slice u32) (y : usize) (z : usize) (ret : slice u32) :
+  (n : nat) (x : slice u32) (y : usize) (z : usize) (ret : slice u32) :
   result (slice u32)
   :=
-  slice_subslice_mut_back u32 x (mk_range y z) ret
+  core_slice_index_Slice_index_mut_back u32 (core_ops_range_Range usize)
+    (core_slice_index_Range_coresliceindexSliceIndexInst u32) x
+    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |} ret
 .
 
 (** [array::array_to_slice_shared_]: forward function *)
-Definition array_to_slice_shared__fwd
+Definition array_to_slice_shared_
   (x : array u32 32%usize) : result (slice u32) :=
-  array_to_slice_shared u32 32%usize x
+  array_to_slice u32 32%usize x
 .
 
 (** [array::array_to_slice_mut_]: forward function *)
-Definition array_to_slice_mut__fwd
-  (x : array u32 32%usize) : result (slice u32) :=
-  array_to_slice_mut_fwd u32 32%usize x
+Definition array_to_slice_mut_ (x : array u32 32%usize) : result (slice u32) :=
+  array_to_slice u32 32%usize x
 .
 
 (** [array::array_to_slice_mut_]: backward function 0 *)
 Definition array_to_slice_mut__back
   (x : array u32 32%usize) (ret : slice u32) : result (array u32 32%usize) :=
-  array_to_slice_mut_back u32 32%usize x ret
+  array_from_slice u32 32%usize x ret
 .
 
 (** [array::array_subslice_shared_]: forward function *)
-Definition array_subslice_shared__fwd
-  (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
-  array_subslice_shared u32 32%usize x (mk_range y z)
+Definition array_subslice_shared_
+  (n : nat) (x : array u32 32%usize) (y : usize) (z : usize) :
+  result (slice u32)
+  :=
+  core_array_Array_index u32 (core_ops_range_Range usize) 32%usize
+    (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
 (** [array::array_subslice_mut_]: forward function *)
-Definition array_subslice_mut__fwd
-  (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
-  array_subslice_mut_fwd u32 32%usize x (mk_range y z)
+Definition array_subslice_mut_
+  (n : nat) (x : array u32 32%usize) (y : usize) (z : usize) :
+  result (slice u32)
+  :=
+  core_array_Array_index_mut u32 (core_ops_range_Range usize) 32%usize
+    (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
 (** [array::array_subslice_mut_]: backward function 0 *)
 Definition array_subslice_mut__back
-  (x : array u32 32%usize) (y : usize) (z : usize) (ret : slice u32) :
+  (n : nat) (x : array u32 32%usize) (y : usize) (z : usize) (ret : slice u32)
+  :
   result (array u32 32%usize)
   :=
-  array_subslice_mut_back u32 32%usize x (mk_range y z) ret
+  core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 32%usize
+    (core_slice_index_Slice_coreopsindexIndexMutInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |} ret
 .
 
 (** [array::index_slice_0]: forward function *)
-Definition index_slice_0_fwd (T : Type) (s : slice T) : result T :=
-  slice_index_shared T s 0%usize
+Definition index_slice_0 (T : Type) (s : slice T) : result T :=
+  slice_index_usize T s 0%usize
 .
 
 (** [array::index_array_0]: forward function *)
-Definition index_array_0_fwd (T : Type) (s : array T 32%usize) : result T :=
-  array_index_shared T 32%usize s 0%usize
+Definition index_array_0 (T : Type) (s : array T 32%usize) : result T :=
+  array_index_usize T 32%usize s 0%usize
 .
 
 (** [array::index_index_array]: forward function *)
-Definition index_index_array_fwd
+Definition index_index_array
   (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
   result u32
   :=
-  a <- array_index_shared (array u32 32%usize) 32%usize s i;
-  array_index_shared u32 32%usize a j
+  a <- array_index_usize (array u32 32%usize) 32%usize s i;
+  array_index_usize u32 32%usize a j
 .
 
-(** [array::const_gen_ret]: forward function *)
-Definition const_gen_ret_fwd (N : usize) : result usize :=
-  Return N.
-
 (** [array::update_update_array]: forward function *)
-Definition update_update_array_fwd
+Definition update_update_array
   (s : array (array u32 32%usize) 32%usize) (i : usize) (j : usize) :
   result unit
   :=
-  a <- array_index_mut_fwd (array u32 32%usize) 32%usize s i;
-  a0 <- array_index_mut_back u32 32%usize a j 0%u32;
-  _ <- array_index_mut_back (array u32 32%usize) 32%usize s i a0;
+  a <- array_index_usize (array u32 32%usize) 32%usize s i;
+  a0 <- array_update_usize u32 32%usize a j 0%u32;
+  _ <- array_update_usize (array u32 32%usize) 32%usize s i a0;
   Return tt
 .
 
 (** [array::array_local_deep_copy]: forward function *)
-Definition array_local_deep_copy_fwd (x : array u32 32%usize) : result unit :=
+Definition array_local_deep_copy (x : array u32 32%usize) : result unit :=
   Return tt
 .
 
 (** [array::take_array]: forward function *)
-Definition take_array_fwd (a : array u32 2%usize) : result unit :=
+Definition take_array (a : array u32 2%usize) : result unit :=
   Return tt.
 
 (** [array::take_array_borrow]: forward function *)
-Definition take_array_borrow_fwd (a : array u32 2%usize) : result unit :=
+Definition take_array_borrow (a : array u32 2%usize) : result unit :=
   Return tt
 .
 
 (** [array::take_slice]: forward function *)
-Definition take_slice_fwd (s : slice u32) : result unit :=
+Definition take_slice (s : slice u32) : result unit :=
   Return tt.
 
 (** [array::take_mut_slice]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition take_mut_slice_fwd_back (s : slice u32) : result (slice u32) :=
-  Return s
-.
+Definition take_mut_slice (s : slice u32) : result (slice u32) :=
+  Return s.
 
 (** [array::take_all]: forward function *)
-Definition take_all_fwd : result unit :=
-  _ <- take_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  _ <- take_array_borrow_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s <-
-    array_to_slice_shared u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  _ <- take_slice_fwd s;
-  s0 <-
-    array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s1 <- take_mut_slice_fwd_back s0;
-  _ <-
-    array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
-      s1;
+Definition take_all : result unit :=
+  _ <- take_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  _ <- take_array_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  _ <- take_slice s;
+  s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  s1 <- take_mut_slice s0;
+  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
   Return tt
 .
 
 (** [array::index_array]: forward function *)
-Definition index_array_fwd (x : array u32 2%usize) : result u32 :=
-  array_index_shared u32 2%usize x 0%usize
+Definition index_array (x : array u32 2%usize) : result u32 :=
+  array_index_usize u32 2%usize x 0%usize
 .
 
 (** [array::index_array_borrow]: forward function *)
-Definition index_array_borrow_fwd (x : array u32 2%usize) : result u32 :=
-  array_index_shared u32 2%usize x 0%usize
+Definition index_array_borrow (x : array u32 2%usize) : result u32 :=
+  array_index_usize u32 2%usize x 0%usize
 .
 
 (** [array::index_slice_u32_0]: forward function *)
-Definition index_slice_u32_0_fwd (x : slice u32) : result u32 :=
-  slice_index_shared u32 x 0%usize
+Definition index_slice_u32_0 (x : slice u32) : result u32 :=
+  slice_index_usize u32 x 0%usize
 .
 
 (** [array::index_mut_slice_u32_0]: forward function *)
-Definition index_mut_slice_u32_0_fwd (x : slice u32) : result u32 :=
-  slice_index_shared u32 x 0%usize
+Definition index_mut_slice_u32_0 (x : slice u32) : result u32 :=
+  slice_index_usize u32 x 0%usize
 .
 
 (** [array::index_mut_slice_u32_0]: backward function 0 *)
 Definition index_mut_slice_u32_0_back (x : slice u32) : result (slice u32) :=
-  _ <- slice_index_shared u32 x 0%usize; Return x
+  _ <- slice_index_usize u32 x 0%usize; Return x
 .
 
 (** [array::index_all]: forward function *)
-Definition index_all_fwd : result u32 :=
-  i <- index_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i0 <- index_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+Definition index_all : result u32 :=
+  i <- index_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  i0 <- index_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   i1 <- u32_add i i0;
-  i2 <- index_array_borrow_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  i2 <- index_array_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   i3 <- u32_add i1 i2;
-  s <-
-    array_to_slice_shared u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i4 <- index_slice_u32_0_fwd s;
+  s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  i4 <- index_slice_u32_0 s;
   i5 <- u32_add i3 i4;
-  s0 <-
-    array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  i6 <- index_mut_slice_u32_0_fwd s0;
+  s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  i6 <- index_mut_slice_u32_0 s0;
   i7 <- u32_add i5 i6;
   s1 <- index_mut_slice_u32_0_back s0;
-  _ <-
-    array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
-      s1;
+  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
   Return i7
 .
 
 (** [array::update_array]: forward function *)
-Definition update_array_fwd (x : array u32 2%usize) : result unit :=
-  _ <- array_index_mut_back u32 2%usize x 0%usize 1%u32; Return tt
+Definition update_array (x : array u32 2%usize) : result unit :=
+  _ <- array_update_usize u32 2%usize x 0%usize 1%u32; Return tt
 .
 
 (** [array::update_array_mut_borrow]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition update_array_mut_borrow_fwd_back
+Definition update_array_mut_borrow
   (x : array u32 2%usize) : result (array u32 2%usize) :=
-  array_index_mut_back u32 2%usize x 0%usize 1%u32
+  array_update_usize u32 2%usize x 0%usize 1%u32
 .
 
 (** [array::update_mut_slice]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition update_mut_slice_fwd_back (x : slice u32) : result (slice u32) :=
-  slice_index_mut_back u32 x 0%usize 1%u32
+Definition update_mut_slice (x : slice u32) : result (slice u32) :=
+  slice_update_usize u32 x 0%usize 1%u32
 .
 
 (** [array::update_all]: forward function *)
-Definition update_all_fwd : result unit :=
-  _ <- update_array_fwd (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  x <-
-    update_array_mut_borrow_fwd_back (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s <- array_to_slice_mut_fwd u32 2%usize x;
-  s0 <- update_mut_slice_fwd_back s;
-  _ <- array_to_slice_mut_back u32 2%usize x s0;
+Definition update_all : result unit :=
+  _ <- update_array (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  x <- update_array_mut_borrow (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  s <- array_to_slice u32 2%usize x;
+  s0 <- update_mut_slice s;
+  _ <- array_from_slice u32 2%usize x s0;
   Return tt
 .
 
 (** [array::range_all]: forward function *)
-Definition range_all_fwd : result unit :=
+Definition range_all (n : nat) : result unit :=
   s <-
-    array_subslice_mut_fwd u32 4%usize
-      (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ]) (mk_range 1%usize
-      3%usize);
-  s0 <- update_mut_slice_fwd_back s;
+    core_array_Array_index_mut u32 (core_ops_range_Range usize) 4%usize
+      (core_slice_index_Slice_coreopsindexIndexMutInst u32
+      (core_ops_range_Range usize)
+      (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+      (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ])
+      {|
+        core_ops_range_Range_start := 1%usize;
+        core_ops_range_Range_end_ := 3%usize
+      |};
+  s0 <- update_mut_slice s;
   _ <-
-    array_subslice_mut_back u32 4%usize
-      (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ]) (mk_range 1%usize
-      3%usize) s0;
+    core_array_Array_index_mut_back u32 (core_ops_range_Range usize) 4%usize
+      (core_slice_index_Slice_coreopsindexIndexMutInst u32
+      (core_ops_range_Range usize)
+      (core_slice_index_Range_coresliceindexSliceIndexInst u32))
+      (mk_array u32 4%usize [ 0%u32; 0%u32; 0%u32; 0%u32 ])
+      {|
+        core_ops_range_Range_start := 1%usize;
+        core_ops_range_Range_end_ := 3%usize
+      |} s0;
   Return tt
 .
 
 (** [array::deref_array_borrow]: forward function *)
-Definition deref_array_borrow_fwd (x : array u32 2%usize) : result u32 :=
-  array_index_shared u32 2%usize x 0%usize
+Definition deref_array_borrow (x : array u32 2%usize) : result u32 :=
+  array_index_usize u32 2%usize x 0%usize
 .
 
 (** [array::deref_array_mut_borrow]: forward function *)
-Definition deref_array_mut_borrow_fwd (x : array u32 2%usize) : result u32 :=
-  array_index_shared u32 2%usize x 0%usize
+Definition deref_array_mut_borrow (x : array u32 2%usize) : result u32 :=
+  array_index_usize u32 2%usize x 0%usize
 .
 
 (** [array::deref_array_mut_borrow]: backward function 0 *)
 Definition deref_array_mut_borrow_back
   (x : array u32 2%usize) : result (array u32 2%usize) :=
-  _ <- array_index_shared u32 2%usize x 0%usize; Return x
+  _ <- array_index_usize u32 2%usize x 0%usize; Return x
 .
 
 (** [array::take_array_t]: forward function *)
-Definition take_array_t_fwd (a : array T_t 2%usize) : result unit :=
+Definition take_array_t (a : array AB_t 2%usize) : result unit :=
   Return tt.
 
 (** [array::non_copyable_array]: forward function *)
-Definition non_copyable_array_fwd : result unit :=
-  _ <- take_array_t_fwd (mk_array T_t 2%usize [ TA; TB ]); Return tt
+Definition non_copyable_array : result unit :=
+  _ <- take_array_t (mk_array AB_t 2%usize [ AB_A; AB_B ]); Return tt
 .
 
 (** [array::sum]: loop 0: forward function *)
-Fixpoint sum_loop_fwd
-  (n : nat) (s : slice u32) (sum : u32) (i : usize) : result u32 :=
+Fixpoint sum_loop
+  (n : nat) (s : slice u32) (sum0 : u32) (i : usize) : result u32 :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     let i0 := slice_len u32 s in
     if i s< i0
     then (
-      i1 <- slice_index_shared u32 s i;
-      sum0 <- u32_add sum i1;
+      i1 <- slice_index_usize u32 s i;
+      sum1 <- u32_add sum0 i1;
       i2 <- usize_add i 1%usize;
-      sum_loop_fwd n0 s sum0 i2)
-    else Return sum
+      sum_loop n0 s sum1 i2)
+    else Return sum0
   end
 .
 
 (** [array::sum]: forward function *)
-Definition sum_fwd (n : nat) (s : slice u32) : result u32 :=
-  sum_loop_fwd n s 0%u32 0%usize
+Definition sum (n : nat) (s : slice u32) : result u32 :=
+  sum_loop n s 0%u32 0%usize
 .
 
 (** [array::sum2]: loop 0: forward function *)
-Fixpoint sum2_loop_fwd
-  (n : nat) (s : slice u32) (s2 : slice u32) (sum : u32) (i : usize) :
+Fixpoint sum2_loop
+  (n : nat) (s : slice u32) (s2 : slice u32) (sum0 : u32) (i : usize) :
   result u32
   :=
   match n with
@@ -386,69 +393,64 @@ Fixpoint sum2_loop_fwd
     let i0 := slice_len u32 s in
     if i s< i0
     then (
-      i1 <- slice_index_shared u32 s i;
-      i2 <- slice_index_shared u32 s2 i;
+      i1 <- slice_index_usize u32 s i;
+      i2 <- slice_index_usize u32 s2 i;
       i3 <- u32_add i1 i2;
-      sum0 <- u32_add sum i3;
+      sum1 <- u32_add sum0 i3;
       i4 <- usize_add i 1%usize;
-      sum2_loop_fwd n0 s s2 sum0 i4)
-    else Return sum
+      sum2_loop n0 s s2 sum1 i4)
+    else Return sum0
   end
 .
 
 (** [array::sum2]: forward function *)
-Definition sum2_fwd (n : nat) (s : slice u32) (s2 : slice u32) : result u32 :=
+Definition sum2 (n : nat) (s : slice u32) (s2 : slice u32) : result u32 :=
   let i := slice_len u32 s in
   let i0 := slice_len u32 s2 in
-  if negb (i s= i0) then Fail_ Failure else sum2_loop_fwd n s s2 0%u32 0%usize
+  if negb (i s= i0) then Fail_ Failure else sum2_loop n s s2 0%u32 0%usize
 .
 
 (** [array::f0]: forward function *)
-Definition f0_fwd : result unit :=
-  s <-
-    array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
-  s0 <- slice_index_mut_back u32 s 0%usize 1%u32;
-  _ <-
-    array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
-      s0;
+Definition f0 : result unit :=
+  s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
+  s0 <- slice_update_usize u32 s 0%usize 1%u32;
+  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]) s0;
   Return tt
 .
 
 (** [array::f1]: forward function *)
-Definition f1_fwd : result unit :=
+Definition f1 : result unit :=
   _ <-
-    array_index_mut_back u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
+    array_update_usize u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
       0%usize 1%u32;
   Return tt
 .
 
 (** [array::f2]: forward function *)
-Definition f2_fwd (i : u32) : result unit :=
+Definition f2 (i : u32) : result unit :=
   Return tt.
 
 (** [array::f4]: forward function *)
-Definition f4_fwd
-  (x : array u32 32%usize) (y : usize) (z : usize) : result (slice u32) :=
-  array_subslice_shared u32 32%usize x (mk_range y z)
+Definition f4
+  (n : nat) (x : array u32 32%usize) (y : usize) (z : usize) :
+  result (slice u32)
+  :=
+  core_array_Array_index u32 (core_ops_range_Range usize) 32%usize
+    (core_slice_index_Slice_coreopsindexIndexInst u32 (core_ops_range_Range
+    usize) (core_slice_index_Range_coresliceindexSliceIndexInst u32)) x
+    {| core_ops_range_Range_start := y; core_ops_range_Range_end_ := z |}
 .
 
 (** [array::f3]: forward function *)
-Definition f3_fwd (n : nat) : result u32 :=
+Definition f3 (n : nat) : result u32 :=
   i <-
-    array_index_shared u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
+    array_index_usize u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ])
       0%usize;
-  _ <- f2_fwd i;
-  s <-
-    array_to_slice_shared u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
-  s0 <-
-    f4_fwd
-      (mk_array u32 32%usize [
-        0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32;
-        0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32;
-        0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32; 0%u32;
-        0%u32; 0%u32
-        ]) 16%usize 18%usize;
-  sum2_fwd n s s0
+  _ <- f2 i;
+  let b := array_repeat u32 32%usize 0%u32 in
+  s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 1%u32; 2%u32 ]);
+  s0 <- f4 n b 16%usize 18%usize;
+  sum2 n s s0
 .
 
 (** [array::SZ] *)
@@ -456,24 +458,18 @@ Definition sz_body : result usize := Return 32%usize.
 Definition sz_c : usize := sz_body%global.
 
 (** [array::f5]: forward function *)
-Definition f5_fwd (x : array u32 32%usize) : result u32 :=
-  array_index_shared u32 32%usize x 0%usize
+Definition f5 (x : array u32 32%usize) : result u32 :=
+  array_index_usize u32 32%usize x 0%usize
 .
 
 (** [array::ite]: forward function *)
-Definition ite_fwd : result unit :=
-  s <-
-    array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
-  s0 <-
-    array_to_slice_mut_fwd u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+Definition ite : result unit :=
+  s <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
+  s0 <- array_to_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]);
   s1 <- index_mut_slice_u32_0_back s0;
-  _ <-
-    array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
-      s1;
+  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s1;
   s2 <- index_mut_slice_u32_0_back s;
-  _ <-
-    array_to_slice_mut_back u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ])
-      s2;
+  _ <- array_from_slice u32 2%usize (mk_array u32 2%usize [ 0%u32; 0%u32 ]) s2;
   Return tt
 .
 
diff --git a/tests/coq/array/Array_Types.v b/tests/coq/array/Array_Types.v
index 7be6dc9b..a13d64e6 100644
--- a/tests/coq/array/Array_Types.v
+++ b/tests/coq/array/Array_Types.v
@@ -8,7 +8,7 @@ Import ListNotations.
 Local Open Scope Primitives_scope.
 Module Array_Types.
 
-(** [array::T] *)
-Inductive T_t := | TA : T_t | TB : T_t.
+(** [array::AB] *)
+Inductive AB_t := | AB_A : AB_t | AB_B : AB_t.
 
 End Array_Types .
diff --git a/tests/coq/array/Primitives.v b/tests/coq/array/Primitives.v
index 8d6c9c8d..85e38f01 100644
--- a/tests/coq/array/Primitives.v
+++ b/tests/coq/array/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
 
 (*** Misc *)
 
-
 Definition string := Coq.Strings.String.string.
 Definition char := Coq.Strings.Ascii.ascii.
 Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
 
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
 
 (*** Scalars *)
 
@@ -408,12 +410,75 @@ Definition core_i64_max   := i64_max %i64.
 Definition core_i128_max  := i64_max %i128.
 Axiom core_isize_max : isize. (** TODO *)
 
-(*** Range *)
-Record range (T : Type) := mk_range {
-  start: T;
-  end_: T;
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+  core_ops_index_Index_Output : Type;
+  core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+  core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+  core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+  core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+  core_ops_deref_Deref_target : Type;
+  core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+  core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+  core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+  core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
 }.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+  core_ops_range_Range_start : T;
+  core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+  core_ops_deref_Deref_target := Self;
+  core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+  core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+  core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+  core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
 
 (*** Arrays *)
 Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -433,51 +498,50 @@ Qed.
 (* TODO: finish the definitions *)
 Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
 
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
 
 (*** Slice *)
 Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
 
 Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
 
 (*** Subslices *)
 
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
 
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
 
 (*** Vectors *)
 
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
 
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
 
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
 
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
 
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
 Proof.
-  unfold vec_length, usize_min.
+  unfold alloc_vec_Vec_length, usize_min.
   split.
   - lia.
   - apply (proj2_sig v).
 Qed.
 
-Definition vec_len (T: Type) (v: vec T) : usize :=
-  exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+  exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
 
 Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
   : list A :=
@@ -488,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
     | S m => x :: (list_update t m a)
 end end.
 
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
-  l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+  l <- f (alloc_vec_Vec_to_list v) ;
   match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
   | left H => Return (exist _ l (scalar_le_max_valid _ _ H))
   | right _ => Fail_ Failure
   end.
 
 (* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
 
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
-  vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
 
 (* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+  if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
 
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l =>
     if to_Z i <? Z.of_nat (length l)
     then Return (list_update l (usize_to_nat i) x)
     else Fail_ Failure).
 
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
-  end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+  core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+  core_slice_index_SliceIndex_Output : Type;
+  core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+  core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+  (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+  x <- inst.(core_slice_index_SliceIndex_get) i s;
+  match x with
+  | None => Fail_ Failure
+  | Some x => Return x
   end.
 
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
-    if to_Z i <? Z.of_nat (length l)
-    then Return (list_update l (usize_to_nat i) x)
-    else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+  (T : Type) :
+  core_ops_range_Range usize -> const_raw_ptr (slice T) -> result (const_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+     sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::get_unchecked_mut]: forward function *)
+Definition core_slice_index_Range_get_unchecked_mut
+  (T : Type) :
+  core_ops_range_Range usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+    sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::index]: forward function *)
+Axiom core_slice_index_Range_index :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (slice T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := slice T;
+  core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (slice T) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_Index (slice T) Idx) :
+  core_ops_index_Index (array T N) Idx := {|
+  core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+  core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_IndexMut (slice T) Idx) :
+  core_ops_index_IndexMut (array T N) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+  core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+  core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+  forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+  forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+  forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+  forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex usize (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := T;
+  core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+  core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+  alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+    alloc_vec_Vec_update_usize v i x.
 
 End Primitives.
diff --git a/tests/coq/betree/BetreeMain_Funs.v b/tests/coq/betree/BetreeMain_Funs.v
index cfa1f8fb..261e8270 100644
--- a/tests/coq/betree/BetreeMain_Funs.v
+++ b/tests/coq/betree/BetreeMain_Funs.v
@@ -13,41 +13,41 @@ Import BetreeMain_Opaque.
 Module BetreeMain_Funs.
 
 (** [betree_main::betree::load_internal_node]: forward function *)
-Definition betree_load_internal_node_fwd
+Definition betree_load_internal_node
   (id : u64) (st : state) :
-  result (state * (Betree_list_t (u64 * Betree_message_t)))
+  result (state * (betree_List_t (u64 * betree_Message_t)))
   :=
-  betree_utils_load_internal_node_fwd id st
+  betree_utils_load_internal_node id st
 .
 
 (** [betree_main::betree::store_internal_node]: forward function *)
-Definition betree_store_internal_node_fwd
-  (id : u64) (content : Betree_list_t (u64 * Betree_message_t)) (st : state) :
+Definition betree_store_internal_node
+  (id : u64) (content : betree_List_t (u64 * betree_Message_t)) (st : state) :
   result (state * unit)
   :=
-  p <- betree_utils_store_internal_node_fwd id content st;
+  p <- betree_utils_store_internal_node id content st;
   let (st0, _) := p in
   Return (st0, tt)
 .
 
 (** [betree_main::betree::load_leaf_node]: forward function *)
-Definition betree_load_leaf_node_fwd
-  (id : u64) (st : state) : result (state * (Betree_list_t (u64 * u64))) :=
-  betree_utils_load_leaf_node_fwd id st
+Definition betree_load_leaf_node
+  (id : u64) (st : state) : result (state * (betree_List_t (u64 * u64))) :=
+  betree_utils_load_leaf_node id st
 .
 
 (** [betree_main::betree::store_leaf_node]: forward function *)
-Definition betree_store_leaf_node_fwd
-  (id : u64) (content : Betree_list_t (u64 * u64)) (st : state) :
+Definition betree_store_leaf_node
+  (id : u64) (content : betree_List_t (u64 * u64)) (st : state) :
   result (state * unit)
   :=
-  p <- betree_utils_store_leaf_node_fwd id content st;
+  p <- betree_utils_store_leaf_node id content st;
   let (st0, _) := p in
   Return (st0, tt)
 .
 
 (** [betree_main::betree::fresh_node_id]: forward function *)
-Definition betree_fresh_node_id_fwd (counter : u64) : result u64 :=
+Definition betree_fresh_node_id (counter : u64) : result u64 :=
   _ <- u64_add counter 1%u64; Return counter
 .
 
@@ -57,1136 +57,1121 @@ Definition betree_fresh_node_id_back (counter : u64) : result u64 :=
 .
 
 (** [betree_main::betree::NodeIdCounter::{0}::new]: forward function *)
-Definition betree_node_id_counter_new_fwd : result Betree_node_id_counter_t :=
-  Return {| Betree_node_id_counter_next_node_id := 0%u64 |}
+Definition betree_NodeIdCounter_new : result betree_NodeIdCounter_t :=
+  Return {| betree_NodeIdCounter_next_node_id := 0%u64 |}
 .
 
 (** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: forward function *)
-Definition betree_node_id_counter_fresh_id_fwd
-  (self : Betree_node_id_counter_t) : result u64 :=
-  _ <- u64_add self.(Betree_node_id_counter_next_node_id) 1%u64;
-  Return self.(Betree_node_id_counter_next_node_id)
+Definition betree_NodeIdCounter_fresh_id
+  (self : betree_NodeIdCounter_t) : result u64 :=
+  _ <- u64_add self.(betree_NodeIdCounter_next_node_id) 1%u64;
+  Return self.(betree_NodeIdCounter_next_node_id)
 .
 
 (** [betree_main::betree::NodeIdCounter::{0}::fresh_id]: backward function 0 *)
-Definition betree_node_id_counter_fresh_id_back
-  (self : Betree_node_id_counter_t) : result Betree_node_id_counter_t :=
-  i <- u64_add self.(Betree_node_id_counter_next_node_id) 1%u64;
-  Return {| Betree_node_id_counter_next_node_id := i |}
+Definition betree_NodeIdCounter_fresh_id_back
+  (self : betree_NodeIdCounter_t) : result betree_NodeIdCounter_t :=
+  i <- u64_add self.(betree_NodeIdCounter_next_node_id) 1%u64;
+  Return {| betree_NodeIdCounter_next_node_id := i |}
 .
 
 (** [betree_main::betree::upsert_update]: forward function *)
-Definition betree_upsert_update_fwd
-  (prev : option u64) (st : Betree_upsert_fun_state_t) : result u64 :=
+Definition betree_upsert_update
+  (prev : option u64) (st : betree_UpsertFunState_t) : result u64 :=
   match prev with
   | None =>
     match st with
-    | BetreeUpsertFunStateAdd v => Return v
-    | BetreeUpsertFunStateSub i => Return 0%u64
+    | Betree_UpsertFunState_Add v => Return v
+    | Betree_UpsertFunState_Sub i => Return 0%u64
     end
   | Some prev0 =>
     match st with
-    | BetreeUpsertFunStateAdd v =>
+    | Betree_UpsertFunState_Add v =>
       margin <- u64_sub core_u64_max prev0;
       if margin s>= v then u64_add prev0 v else Return core_u64_max
-    | BetreeUpsertFunStateSub v =>
+    | Betree_UpsertFunState_Sub v =>
       if prev0 s>= v then u64_sub prev0 v else Return 0%u64
     end
   end
 .
 
 (** [betree_main::betree::List::{1}::len]: forward function *)
-Fixpoint betree_list_len_fwd
-  (T : Type) (n : nat) (self : Betree_list_t T) : result u64 :=
+Fixpoint betree_List_len
+  (T : Type) (n : nat) (self : betree_List_t T) : result u64 :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match self with
-    | BetreeListCons t tl => i <- betree_list_len_fwd T n0 tl; u64_add 1%u64 i
-    | BetreeListNil => Return 0%u64
+    | Betree_List_Cons t tl => i <- betree_List_len T n0 tl; u64_add 1%u64 i
+    | Betree_List_Nil => Return 0%u64
     end
   end
 .
 
 (** [betree_main::betree::List::{1}::split_at]: forward function *)
-Fixpoint betree_list_split_at_fwd
-  (T : Type) (n : nat) (self : Betree_list_t T) (n0 : u64) :
-  result ((Betree_list_t T) * (Betree_list_t T))
+Fixpoint betree_List_split_at
+  (T : Type) (n : nat) (self : betree_List_t T) (n0 : u64) :
+  result ((betree_List_t T) * (betree_List_t T))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n1 =>
     if n0 s= 0%u64
-    then Return (BetreeListNil, self)
+    then Return (Betree_List_Nil, self)
     else
       match self with
-      | BetreeListCons hd tl =>
+      | Betree_List_Cons hd tl =>
         i <- u64_sub n0 1%u64;
-        p <- betree_list_split_at_fwd T n1 tl i;
+        p <- betree_List_split_at T n1 tl i;
         let (ls0, ls1) := p in
         let l := ls0 in
-        Return (BetreeListCons hd l, ls1)
-      | BetreeListNil => Fail_ Failure
+        Return (Betree_List_Cons hd l, ls1)
+      | Betree_List_Nil => Fail_ Failure
       end
   end
 .
 
 (** [betree_main::betree::List::{1}::push_front]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition betree_list_push_front_fwd_back
-  (T : Type) (self : Betree_list_t T) (x : T) : result (Betree_list_t T) :=
-  let tl := mem_replace_fwd (Betree_list_t T) self BetreeListNil in
+Definition betree_List_push_front
+  (T : Type) (self : betree_List_t T) (x : T) : result (betree_List_t T) :=
+  let tl := core_mem_replace (betree_List_t T) self Betree_List_Nil in
   let l := tl in
-  Return (BetreeListCons x l)
+  Return (Betree_List_Cons x l)
 .
 
 (** [betree_main::betree::List::{1}::pop_front]: forward function *)
-Definition betree_list_pop_front_fwd
-  (T : Type) (self : Betree_list_t T) : result T :=
-  let ls := mem_replace_fwd (Betree_list_t T) self BetreeListNil in
+Definition betree_List_pop_front
+  (T : Type) (self : betree_List_t T) : result T :=
+  let ls := core_mem_replace (betree_List_t T) self Betree_List_Nil in
   match ls with
-  | BetreeListCons x tl => Return x
-  | BetreeListNil => Fail_ Failure
+  | Betree_List_Cons x tl => Return x
+  | Betree_List_Nil => Fail_ Failure
   end
 .
 
 (** [betree_main::betree::List::{1}::pop_front]: backward function 0 *)
-Definition betree_list_pop_front_back
-  (T : Type) (self : Betree_list_t T) : result (Betree_list_t T) :=
-  let ls := mem_replace_fwd (Betree_list_t T) self BetreeListNil in
+Definition betree_List_pop_front_back
+  (T : Type) (self : betree_List_t T) : result (betree_List_t T) :=
+  let ls := core_mem_replace (betree_List_t T) self Betree_List_Nil in
   match ls with
-  | BetreeListCons x tl => Return tl
-  | BetreeListNil => Fail_ Failure
+  | Betree_List_Cons x tl => Return tl
+  | Betree_List_Nil => Fail_ Failure
   end
 .
 
 (** [betree_main::betree::List::{1}::hd]: forward function *)
-Definition betree_list_hd_fwd (T : Type) (self : Betree_list_t T) : result T :=
+Definition betree_List_hd (T : Type) (self : betree_List_t T) : result T :=
   match self with
-  | BetreeListCons hd l => Return hd
-  | BetreeListNil => Fail_ Failure
+  | Betree_List_Cons hd l => Return hd
+  | Betree_List_Nil => Fail_ Failure
   end
 .
 
 (** [betree_main::betree::List::{2}::head_has_key]: forward function *)
-Definition betree_list_head_has_key_fwd
-  (T : Type) (self : Betree_list_t (u64 * T)) (key : u64) : result bool :=
+Definition betree_List_head_has_key
+  (T : Type) (self : betree_List_t (u64 * T)) (key : u64) : result bool :=
   match self with
-  | BetreeListCons hd l => let (i, _) := hd in Return (i s= key)
-  | BetreeListNil => Return false
+  | Betree_List_Cons hd l => let (i, _) := hd in Return (i s= key)
+  | Betree_List_Nil => Return false
   end
 .
 
 (** [betree_main::betree::List::{2}::partition_at_pivot]: forward function *)
-Fixpoint betree_list_partition_at_pivot_fwd
-  (T : Type) (n : nat) (self : Betree_list_t (u64 * T)) (pivot : u64) :
-  result ((Betree_list_t (u64 * T)) * (Betree_list_t (u64 * T)))
+Fixpoint betree_List_partition_at_pivot
+  (T : Type) (n : nat) (self : betree_List_t (u64 * T)) (pivot : u64) :
+  result ((betree_List_t (u64 * T)) * (betree_List_t (u64 * T)))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match self with
-    | BetreeListCons hd tl =>
+    | Betree_List_Cons hd tl =>
       let (i, t) := hd in
       if i s>= pivot
-      then Return (BetreeListNil, BetreeListCons (i, t) tl)
+      then Return (Betree_List_Nil, Betree_List_Cons (i, t) tl)
       else (
-        p <- betree_list_partition_at_pivot_fwd T n0 tl pivot;
+        p <- betree_List_partition_at_pivot T n0 tl pivot;
         let (ls0, ls1) := p in
         let l := ls0 in
-        Return (BetreeListCons (i, t) l, ls1))
-    | BetreeListNil => Return (BetreeListNil, BetreeListNil)
+        Return (Betree_List_Cons (i, t) l, ls1))
+    | Betree_List_Nil => Return (Betree_List_Nil, Betree_List_Nil)
     end
   end
 .
 
 (** [betree_main::betree::Leaf::{3}::split]: forward function *)
-Definition betree_leaf_split_fwd
-  (n : nat) (self : Betree_leaf_t) (content : Betree_list_t (u64 * u64))
-  (params : Betree_params_t) (node_id_cnt : Betree_node_id_counter_t)
+Definition betree_Leaf_split
+  (n : nat) (self : betree_Leaf_t) (content : betree_List_t (u64 * u64))
+  (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
   (st : state) :
-  result (state * Betree_internal_t)
+  result (state * betree_Internal_t)
   :=
   p <-
-    betree_list_split_at_fwd (u64 * u64) n content
-      params.(Betree_params_split_size);
+    betree_List_split_at (u64 * u64) n content
+      params.(betree_Params_split_size);
   let (content0, content1) := p in
-  p0 <- betree_list_hd_fwd (u64 * u64) content1;
+  p0 <- betree_List_hd (u64 * u64) content1;
   let (pivot, _) := p0 in
-  id0 <- betree_node_id_counter_fresh_id_fwd node_id_cnt;
-  node_id_cnt0 <- betree_node_id_counter_fresh_id_back node_id_cnt;
-  id1 <- betree_node_id_counter_fresh_id_fwd node_id_cnt0;
-  p1 <- betree_store_leaf_node_fwd id0 content0 st;
+  id0 <- betree_NodeIdCounter_fresh_id node_id_cnt;
+  node_id_cnt0 <- betree_NodeIdCounter_fresh_id_back node_id_cnt;
+  id1 <- betree_NodeIdCounter_fresh_id node_id_cnt0;
+  p1 <- betree_store_leaf_node id0 content0 st;
   let (st0, _) := p1 in
-  p2 <- betree_store_leaf_node_fwd id1 content1 st0;
+  p2 <- betree_store_leaf_node id1 content1 st0;
   let (st1, _) := p2 in
-  let n0 := BetreeNodeLeaf
+  let n0 := Betree_Node_Leaf
     {|
-      Betree_leaf_id := id0;
-      Betree_leaf_size := params.(Betree_params_split_size)
+      betree_Leaf_id := id0;
+      betree_Leaf_size := params.(betree_Params_split_size)
     |} in
-  let n1 := BetreeNodeLeaf
+  let n1 := Betree_Node_Leaf
     {|
-      Betree_leaf_id := id1;
-      Betree_leaf_size := params.(Betree_params_split_size)
+      betree_Leaf_id := id1;
+      betree_Leaf_size := params.(betree_Params_split_size)
     |} in
-  Return (st1, mkBetree_internal_t self.(Betree_leaf_id) pivot n0 n1)
+  Return (st1, mkbetree_Internal_t self.(betree_Leaf_id) pivot n0 n1)
 .
 
 (** [betree_main::betree::Leaf::{3}::split]: backward function 2 *)
-Definition betree_leaf_split_back
-  (n : nat) (self : Betree_leaf_t) (content : Betree_list_t (u64 * u64))
-  (params : Betree_params_t) (node_id_cnt : Betree_node_id_counter_t)
+Definition betree_Leaf_split_back
+  (n : nat) (self : betree_Leaf_t) (content : betree_List_t (u64 * u64))
+  (params : betree_Params_t) (node_id_cnt : betree_NodeIdCounter_t)
   (st : state) :
-  result Betree_node_id_counter_t
+  result betree_NodeIdCounter_t
   :=
   p <-
-    betree_list_split_at_fwd (u64 * u64) n content
-      params.(Betree_params_split_size);
+    betree_List_split_at (u64 * u64) n content
+      params.(betree_Params_split_size);
   let (content0, content1) := p in
-  _ <- betree_list_hd_fwd (u64 * u64) content1;
-  id0 <- betree_node_id_counter_fresh_id_fwd node_id_cnt;
-  node_id_cnt0 <- betree_node_id_counter_fresh_id_back node_id_cnt;
-  id1 <- betree_node_id_counter_fresh_id_fwd node_id_cnt0;
-  p0 <- betree_store_leaf_node_fwd id0 content0 st;
+  _ <- betree_List_hd (u64 * u64) content1;
+  id0 <- betree_NodeIdCounter_fresh_id node_id_cnt;
+  node_id_cnt0 <- betree_NodeIdCounter_fresh_id_back node_id_cnt;
+  id1 <- betree_NodeIdCounter_fresh_id node_id_cnt0;
+  p0 <- betree_store_leaf_node id0 content0 st;
   let (st0, _) := p0 in
-  _ <- betree_store_leaf_node_fwd id1 content1 st0;
-  betree_node_id_counter_fresh_id_back node_id_cnt0
+  _ <- betree_store_leaf_node id1 content1 st0;
+  betree_NodeIdCounter_fresh_id_back node_id_cnt0
 .
 
 (** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: forward function *)
-Fixpoint betree_node_lookup_first_message_for_key_fwd
-  (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t)) :
-  result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_for_key
+  (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t)) :
+  result (betree_List_t (u64 * betree_Message_t))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match msgs with
-    | BetreeListCons x next_msgs =>
+    | Betree_List_Cons x next_msgs =>
       let (i, m) := x in
       if i s>= key
-      then Return (BetreeListCons (i, m) next_msgs)
-      else betree_node_lookup_first_message_for_key_fwd n0 key next_msgs
-    | BetreeListNil => Return BetreeListNil
+      then Return (Betree_List_Cons (i, m) next_msgs)
+      else betree_Node_lookup_first_message_for_key n0 key next_msgs
+    | Betree_List_Nil => Return Betree_List_Nil
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::lookup_first_message_for_key]: backward function 0 *)
-Fixpoint betree_node_lookup_first_message_for_key_back
-  (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t))
-  (ret : Betree_list_t (u64 * Betree_message_t)) :
-  result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_for_key_back
+  (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t))
+  (ret : betree_List_t (u64 * betree_Message_t)) :
+  result (betree_List_t (u64 * betree_Message_t))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match msgs with
-    | BetreeListCons x next_msgs =>
+    | Betree_List_Cons x next_msgs =>
       let (i, m) := x in
       if i s>= key
       then Return ret
       else (
         next_msgs0 <-
-          betree_node_lookup_first_message_for_key_back n0 key next_msgs ret;
-        Return (BetreeListCons (i, m) next_msgs0))
-    | BetreeListNil => Return ret
+          betree_Node_lookup_first_message_for_key_back n0 key next_msgs ret;
+        Return (Betree_List_Cons (i, m) next_msgs0))
+    | Betree_List_Nil => Return ret
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::apply_upserts]: forward function *)
-Fixpoint betree_node_apply_upserts_fwd
-  (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t)) (prev : option u64)
+Fixpoint betree_Node_apply_upserts
+  (n : nat) (msgs : betree_List_t (u64 * betree_Message_t)) (prev : option u64)
   (key : u64) (st : state) :
   result (state * u64)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    b <- betree_list_head_has_key_fwd Betree_message_t msgs key;
+    b <- betree_List_head_has_key betree_Message_t msgs key;
     if b
     then (
-      msg <- betree_list_pop_front_fwd (u64 * Betree_message_t) msgs;
+      msg <- betree_List_pop_front (u64 * betree_Message_t) msgs;
       let (_, m) := msg in
       match m with
-      | BetreeMessageInsert i => Fail_ Failure
-      | BetreeMessageDelete => Fail_ Failure
-      | BetreeMessageUpsert s =>
-        v <- betree_upsert_update_fwd prev s;
-        msgs0 <- betree_list_pop_front_back (u64 * Betree_message_t) msgs;
-        betree_node_apply_upserts_fwd n0 msgs0 (Some v) key st
+      | Betree_Message_Insert i => Fail_ Failure
+      | Betree_Message_Delete => Fail_ Failure
+      | Betree_Message_Upsert s =>
+        v <- betree_upsert_update prev s;
+        msgs0 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs;
+        betree_Node_apply_upserts n0 msgs0 (Some v) key st
       end)
     else (
-      p <- core_option_option_unwrap_fwd u64 prev st;
+      p <- core_option_Option_unwrap u64 prev st;
       let (st0, v) := p in
       _ <-
-        betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs (key,
-          BetreeMessageInsert v);
+        betree_List_push_front (u64 * betree_Message_t) msgs (key,
+          Betree_Message_Insert v);
       Return (st0, v))
   end
 .
 
 (** [betree_main::betree::Node::{5}::apply_upserts]: backward function 0 *)
-Fixpoint betree_node_apply_upserts_back
-  (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t)) (prev : option u64)
+Fixpoint betree_Node_apply_upserts_back
+  (n : nat) (msgs : betree_List_t (u64 * betree_Message_t)) (prev : option u64)
   (key : u64) (st : state) :
-  result (Betree_list_t (u64 * Betree_message_t))
+  result (betree_List_t (u64 * betree_Message_t))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    b <- betree_list_head_has_key_fwd Betree_message_t msgs key;
+    b <- betree_List_head_has_key betree_Message_t msgs key;
     if b
     then (
-      msg <- betree_list_pop_front_fwd (u64 * Betree_message_t) msgs;
+      msg <- betree_List_pop_front (u64 * betree_Message_t) msgs;
       let (_, m) := msg in
       match m with
-      | BetreeMessageInsert i => Fail_ Failure
-      | BetreeMessageDelete => Fail_ Failure
-      | BetreeMessageUpsert s =>
-        v <- betree_upsert_update_fwd prev s;
-        msgs0 <- betree_list_pop_front_back (u64 * Betree_message_t) msgs;
-        betree_node_apply_upserts_back n0 msgs0 (Some v) key st
+      | Betree_Message_Insert i => Fail_ Failure
+      | Betree_Message_Delete => Fail_ Failure
+      | Betree_Message_Upsert s =>
+        v <- betree_upsert_update prev s;
+        msgs0 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs;
+        betree_Node_apply_upserts_back n0 msgs0 (Some v) key st
       end)
     else (
-      p <- core_option_option_unwrap_fwd u64 prev st;
+      p <- core_option_Option_unwrap u64 prev st;
       let (_, v) := p in
-      betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs (key,
-        BetreeMessageInsert v))
+      betree_List_push_front (u64 * betree_Message_t) msgs (key,
+        Betree_Message_Insert v))
   end
 .
 
 (** [betree_main::betree::Node::{5}::lookup_in_bindings]: forward function *)
-Fixpoint betree_node_lookup_in_bindings_fwd
-  (n : nat) (key : u64) (bindings : Betree_list_t (u64 * u64)) :
+Fixpoint betree_Node_lookup_in_bindings
+  (n : nat) (key : u64) (bindings : betree_List_t (u64 * u64)) :
   result (option u64)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match bindings with
-    | BetreeListCons hd tl =>
+    | Betree_List_Cons hd tl =>
       let (i, i0) := hd in
       if i s= key
       then Return (Some i0)
       else
         if i s> key
         then Return None
-        else betree_node_lookup_in_bindings_fwd n0 key tl
-    | BetreeListNil => Return None
+        else betree_Node_lookup_in_bindings n0 key tl
+    | Betree_List_Nil => Return None
     end
   end
 .
 
 (** [betree_main::betree::Internal::{4}::lookup_in_children]: forward function *)
-Fixpoint betree_internal_lookup_in_children_fwd
-  (n : nat) (self : Betree_internal_t) (key : u64) (st : state) :
+Fixpoint betree_Internal_lookup_in_children
+  (n : nat) (self : betree_Internal_t) (key : u64) (st : state) :
   result (state * (option u64))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    if key s< self.(Betree_internal_pivot)
-    then betree_node_lookup_fwd n0 self.(Betree_internal_left) key st
-    else betree_node_lookup_fwd n0 self.(Betree_internal_right) key st
+    if key s< self.(betree_Internal_pivot)
+    then betree_Node_lookup n0 self.(betree_Internal_left) key st
+    else betree_Node_lookup n0 self.(betree_Internal_right) key st
   end
 
 (** [betree_main::betree::Internal::{4}::lookup_in_children]: backward function 0 *)
-with betree_internal_lookup_in_children_back
-  (n : nat) (self : Betree_internal_t) (key : u64) (st : state) :
-  result Betree_internal_t
+with betree_Internal_lookup_in_children_back
+  (n : nat) (self : betree_Internal_t) (key : u64) (st : state) :
+  result betree_Internal_t
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    if key s< self.(Betree_internal_pivot)
+    if key s< self.(betree_Internal_pivot)
     then (
-      n1 <- betree_node_lookup_back n0 self.(Betree_internal_left) key st;
-      Return (mkBetree_internal_t self.(Betree_internal_id)
-        self.(Betree_internal_pivot) n1 self.(Betree_internal_right)))
+      n1 <- betree_Node_lookup_back n0 self.(betree_Internal_left) key st;
+      Return (mkbetree_Internal_t self.(betree_Internal_id)
+        self.(betree_Internal_pivot) n1 self.(betree_Internal_right)))
     else (
-      n1 <- betree_node_lookup_back n0 self.(Betree_internal_right) key st;
-      Return (mkBetree_internal_t self.(Betree_internal_id)
-        self.(Betree_internal_pivot) self.(Betree_internal_left) n1))
+      n1 <- betree_Node_lookup_back n0 self.(betree_Internal_right) key st;
+      Return (mkbetree_Internal_t self.(betree_Internal_id)
+        self.(betree_Internal_pivot) self.(betree_Internal_left) n1))
   end
 
 (** [betree_main::betree::Node::{5}::lookup]: forward function *)
-with betree_node_lookup_fwd
-  (n : nat) (self : Betree_node_t) (key : u64) (st : state) :
+with betree_Node_lookup
+  (n : nat) (self : betree_Node_t) (key : u64) (st : state) :
   result (state * (option u64))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match self with
-    | BetreeNodeInternal node =>
-      p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+    | Betree_Node_Internal node =>
+      p <- betree_load_internal_node node.(betree_Internal_id) st;
       let (st0, msgs) := p in
-      pending <- betree_node_lookup_first_message_for_key_fwd n0 key msgs;
+      pending <- betree_Node_lookup_first_message_for_key n0 key msgs;
       match pending with
-      | BetreeListCons p0 l =>
+      | Betree_List_Cons p0 l =>
         let (k, msg) := p0 in
         if k s<> key
         then (
-          p1 <- betree_internal_lookup_in_children_fwd n0 node key st0;
-          let (st1, opt) := p1 in
+          p1 <- betree_Internal_lookup_in_children n0 node key st0;
+          let (st1, o) := p1 in
           _ <-
-            betree_node_lookup_first_message_for_key_back n0 key msgs
-              (BetreeListCons (k, msg) l);
-          Return (st1, opt))
+            betree_Node_lookup_first_message_for_key_back n0 key msgs
+              (Betree_List_Cons (k, msg) l);
+          Return (st1, o))
         else
           match msg with
-          | BetreeMessageInsert v =>
+          | Betree_Message_Insert v =>
             _ <-
-              betree_node_lookup_first_message_for_key_back n0 key msgs
-                (BetreeListCons (k, BetreeMessageInsert v) l);
+              betree_Node_lookup_first_message_for_key_back n0 key msgs
+                (Betree_List_Cons (k, Betree_Message_Insert v) l);
             Return (st0, Some v)
-          | BetreeMessageDelete =>
+          | Betree_Message_Delete =>
             _ <-
-              betree_node_lookup_first_message_for_key_back n0 key msgs
-                (BetreeListCons (k, BetreeMessageDelete) l);
+              betree_Node_lookup_first_message_for_key_back n0 key msgs
+                (Betree_List_Cons (k, Betree_Message_Delete) l);
             Return (st0, None)
-          | BetreeMessageUpsert ufs =>
-            p1 <- betree_internal_lookup_in_children_fwd n0 node key st0;
+          | Betree_Message_Upsert ufs =>
+            p1 <- betree_Internal_lookup_in_children n0 node key st0;
             let (st1, v) := p1 in
             p2 <-
-              betree_node_apply_upserts_fwd n0 (BetreeListCons (k,
-                BetreeMessageUpsert ufs) l) v key st1;
+              betree_Node_apply_upserts n0 (Betree_List_Cons (k,
+                Betree_Message_Upsert ufs) l) v key st1;
             let (st2, v0) := p2 in
-            node0 <- betree_internal_lookup_in_children_back n0 node key st0;
+            node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
             pending0 <-
-              betree_node_apply_upserts_back n0 (BetreeListCons (k,
-                BetreeMessageUpsert ufs) l) v key st1;
+              betree_Node_apply_upserts_back n0 (Betree_List_Cons (k,
+                Betree_Message_Upsert ufs) l) v key st1;
             msgs0 <-
-              betree_node_lookup_first_message_for_key_back n0 key msgs
+              betree_Node_lookup_first_message_for_key_back n0 key msgs
                 pending0;
             p3 <-
-              betree_store_internal_node_fwd node0.(Betree_internal_id) msgs0
-                st2;
+              betree_store_internal_node node0.(betree_Internal_id) msgs0 st2;
             let (st3, _) := p3 in
             Return (st3, Some v0)
           end
-      | BetreeListNil =>
-        p0 <- betree_internal_lookup_in_children_fwd n0 node key st0;
-        let (st1, opt) := p0 in
+      | Betree_List_Nil =>
+        p0 <- betree_Internal_lookup_in_children n0 node key st0;
+        let (st1, o) := p0 in
         _ <-
-          betree_node_lookup_first_message_for_key_back n0 key msgs
-            BetreeListNil;
-        Return (st1, opt)
+          betree_Node_lookup_first_message_for_key_back n0 key msgs
+            Betree_List_Nil;
+        Return (st1, o)
       end
-    | BetreeNodeLeaf node =>
-      p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+    | Betree_Node_Leaf node =>
+      p <- betree_load_leaf_node node.(betree_Leaf_id) st;
       let (st0, bindings) := p in
-      opt <- betree_node_lookup_in_bindings_fwd n0 key bindings;
-      Return (st0, opt)
+      o <- betree_Node_lookup_in_bindings n0 key bindings;
+      Return (st0, o)
     end
   end
 
 (** [betree_main::betree::Node::{5}::lookup]: backward function 0 *)
-with betree_node_lookup_back
-  (n : nat) (self : Betree_node_t) (key : u64) (st : state) :
-  result Betree_node_t
+with betree_Node_lookup_back
+  (n : nat) (self : betree_Node_t) (key : u64) (st : state) :
+  result betree_Node_t
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match self with
-    | BetreeNodeInternal node =>
-      p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+    | Betree_Node_Internal node =>
+      p <- betree_load_internal_node node.(betree_Internal_id) st;
       let (st0, msgs) := p in
-      pending <- betree_node_lookup_first_message_for_key_fwd n0 key msgs;
+      pending <- betree_Node_lookup_first_message_for_key n0 key msgs;
       match pending with
-      | BetreeListCons p0 l =>
+      | Betree_List_Cons p0 l =>
         let (k, msg) := p0 in
         if k s<> key
         then (
           _ <-
-            betree_node_lookup_first_message_for_key_back n0 key msgs
-              (BetreeListCons (k, msg) l);
-          node0 <- betree_internal_lookup_in_children_back n0 node key st0;
-          Return (BetreeNodeInternal node0))
+            betree_Node_lookup_first_message_for_key_back n0 key msgs
+              (Betree_List_Cons (k, msg) l);
+          node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
+          Return (Betree_Node_Internal node0))
         else
           match msg with
-          | BetreeMessageInsert v =>
+          | Betree_Message_Insert v =>
             _ <-
-              betree_node_lookup_first_message_for_key_back n0 key msgs
-                (BetreeListCons (k, BetreeMessageInsert v) l);
-            Return (BetreeNodeInternal node)
-          | BetreeMessageDelete =>
+              betree_Node_lookup_first_message_for_key_back n0 key msgs
+                (Betree_List_Cons (k, Betree_Message_Insert v) l);
+            Return (Betree_Node_Internal node)
+          | Betree_Message_Delete =>
             _ <-
-              betree_node_lookup_first_message_for_key_back n0 key msgs
-                (BetreeListCons (k, BetreeMessageDelete) l);
-            Return (BetreeNodeInternal node)
-          | BetreeMessageUpsert ufs =>
-            p1 <- betree_internal_lookup_in_children_fwd n0 node key st0;
+              betree_Node_lookup_first_message_for_key_back n0 key msgs
+                (Betree_List_Cons (k, Betree_Message_Delete) l);
+            Return (Betree_Node_Internal node)
+          | Betree_Message_Upsert ufs =>
+            p1 <- betree_Internal_lookup_in_children n0 node key st0;
             let (st1, v) := p1 in
             p2 <-
-              betree_node_apply_upserts_fwd n0 (BetreeListCons (k,
-                BetreeMessageUpsert ufs) l) v key st1;
+              betree_Node_apply_upserts n0 (Betree_List_Cons (k,
+                Betree_Message_Upsert ufs) l) v key st1;
             let (st2, _) := p2 in
-            node0 <- betree_internal_lookup_in_children_back n0 node key st0;
+            node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
             pending0 <-
-              betree_node_apply_upserts_back n0 (BetreeListCons (k,
-                BetreeMessageUpsert ufs) l) v key st1;
+              betree_Node_apply_upserts_back n0 (Betree_List_Cons (k,
+                Betree_Message_Upsert ufs) l) v key st1;
             msgs0 <-
-              betree_node_lookup_first_message_for_key_back n0 key msgs
+              betree_Node_lookup_first_message_for_key_back n0 key msgs
                 pending0;
             _ <-
-              betree_store_internal_node_fwd node0.(Betree_internal_id) msgs0
-                st2;
-            Return (BetreeNodeInternal node0)
+              betree_store_internal_node node0.(betree_Internal_id) msgs0 st2;
+            Return (Betree_Node_Internal node0)
           end
-      | BetreeListNil =>
+      | Betree_List_Nil =>
         _ <-
-          betree_node_lookup_first_message_for_key_back n0 key msgs
-            BetreeListNil;
-        node0 <- betree_internal_lookup_in_children_back n0 node key st0;
-        Return (BetreeNodeInternal node0)
+          betree_Node_lookup_first_message_for_key_back n0 key msgs
+            Betree_List_Nil;
+        node0 <- betree_Internal_lookup_in_children_back n0 node key st0;
+        Return (Betree_Node_Internal node0)
       end
-    | BetreeNodeLeaf node =>
-      p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+    | Betree_Node_Leaf node =>
+      p <- betree_load_leaf_node node.(betree_Leaf_id) st;
       let (_, bindings) := p in
-      _ <- betree_node_lookup_in_bindings_fwd n0 key bindings;
-      Return (BetreeNodeLeaf node)
+      _ <- betree_Node_lookup_in_bindings n0 key bindings;
+      Return (Betree_Node_Leaf node)
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::filter_messages_for_key]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint betree_node_filter_messages_for_key_fwd_back
-  (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t)) :
-  result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_filter_messages_for_key
+  (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t)) :
+  result (betree_List_t (u64 * betree_Message_t))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match msgs with
-    | BetreeListCons p l =>
+    | Betree_List_Cons p l =>
       let (k, m) := p in
       if k s= key
       then (
         msgs0 <-
-          betree_list_pop_front_back (u64 * Betree_message_t) (BetreeListCons
+          betree_List_pop_front_back (u64 * betree_Message_t) (Betree_List_Cons
             (k, m) l);
-        betree_node_filter_messages_for_key_fwd_back n0 key msgs0)
-      else Return (BetreeListCons (k, m) l)
-    | BetreeListNil => Return BetreeListNil
+        betree_Node_filter_messages_for_key n0 key msgs0)
+      else Return (Betree_List_Cons (k, m) l)
+    | Betree_List_Nil => Return Betree_List_Nil
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: forward function *)
-Fixpoint betree_node_lookup_first_message_after_key_fwd
-  (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t)) :
-  result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_after_key
+  (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t)) :
+  result (betree_List_t (u64 * betree_Message_t))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match msgs with
-    | BetreeListCons p next_msgs =>
+    | Betree_List_Cons p next_msgs =>
       let (k, m) := p in
       if k s= key
-      then betree_node_lookup_first_message_after_key_fwd n0 key next_msgs
-      else Return (BetreeListCons (k, m) next_msgs)
-    | BetreeListNil => Return BetreeListNil
+      then betree_Node_lookup_first_message_after_key n0 key next_msgs
+      else Return (Betree_List_Cons (k, m) next_msgs)
+    | Betree_List_Nil => Return Betree_List_Nil
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::lookup_first_message_after_key]: backward function 0 *)
-Fixpoint betree_node_lookup_first_message_after_key_back
-  (n : nat) (key : u64) (msgs : Betree_list_t (u64 * Betree_message_t))
-  (ret : Betree_list_t (u64 * Betree_message_t)) :
-  result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_lookup_first_message_after_key_back
+  (n : nat) (key : u64) (msgs : betree_List_t (u64 * betree_Message_t))
+  (ret : betree_List_t (u64 * betree_Message_t)) :
+  result (betree_List_t (u64 * betree_Message_t))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match msgs with
-    | BetreeListCons p next_msgs =>
+    | Betree_List_Cons p next_msgs =>
       let (k, m) := p in
       if k s= key
       then (
         next_msgs0 <-
-          betree_node_lookup_first_message_after_key_back n0 key next_msgs ret;
-        Return (BetreeListCons (k, m) next_msgs0))
+          betree_Node_lookup_first_message_after_key_back n0 key next_msgs ret;
+        Return (Betree_List_Cons (k, m) next_msgs0))
       else Return ret
-    | BetreeListNil => Return ret
+    | Betree_List_Nil => Return ret
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::apply_to_internal]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition betree_node_apply_to_internal_fwd_back
-  (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t)) (key : u64)
-  (new_msg : Betree_message_t) :
-  result (Betree_list_t (u64 * Betree_message_t))
+Definition betree_Node_apply_to_internal
+  (n : nat) (msgs : betree_List_t (u64 * betree_Message_t)) (key : u64)
+  (new_msg : betree_Message_t) :
+  result (betree_List_t (u64 * betree_Message_t))
   :=
-  msgs0 <- betree_node_lookup_first_message_for_key_fwd n key msgs;
-  b <- betree_list_head_has_key_fwd Betree_message_t msgs0 key;
+  msgs0 <- betree_Node_lookup_first_message_for_key n key msgs;
+  b <- betree_List_head_has_key betree_Message_t msgs0 key;
   if b
   then
     match new_msg with
-    | BetreeMessageInsert i =>
-      msgs1 <- betree_node_filter_messages_for_key_fwd_back n key msgs0;
+    | Betree_Message_Insert i =>
+      msgs1 <- betree_Node_filter_messages_for_key n key msgs0;
       msgs2 <-
-        betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
-          BetreeMessageInsert i);
-      betree_node_lookup_first_message_for_key_back n key msgs msgs2
-    | BetreeMessageDelete =>
-      msgs1 <- betree_node_filter_messages_for_key_fwd_back n key msgs0;
+        betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+          Betree_Message_Insert i);
+      betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+    | Betree_Message_Delete =>
+      msgs1 <- betree_Node_filter_messages_for_key n key msgs0;
       msgs2 <-
-        betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
-          BetreeMessageDelete);
-      betree_node_lookup_first_message_for_key_back n key msgs msgs2
-    | BetreeMessageUpsert s =>
-      p <- betree_list_hd_fwd (u64 * Betree_message_t) msgs0;
+        betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+          Betree_Message_Delete);
+      betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+    | Betree_Message_Upsert s =>
+      p <- betree_List_hd (u64 * betree_Message_t) msgs0;
       let (_, m) := p in
       match m with
-      | BetreeMessageInsert prev =>
-        v <- betree_upsert_update_fwd (Some prev) s;
-        msgs1 <- betree_list_pop_front_back (u64 * Betree_message_t) msgs0;
+      | Betree_Message_Insert prev =>
+        v <- betree_upsert_update (Some prev) s;
+        msgs1 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs0;
         msgs2 <-
-          betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
-            BetreeMessageInsert v);
-        betree_node_lookup_first_message_for_key_back n key msgs msgs2
-      | BetreeMessageDelete =>
-        v <- betree_upsert_update_fwd None s;
-        msgs1 <- betree_list_pop_front_back (u64 * Betree_message_t) msgs0;
+          betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+            Betree_Message_Insert v);
+        betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+      | Betree_Message_Delete =>
+        v <- betree_upsert_update None s;
+        msgs1 <- betree_List_pop_front_back (u64 * betree_Message_t) msgs0;
         msgs2 <-
-          betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
-            BetreeMessageInsert v);
-        betree_node_lookup_first_message_for_key_back n key msgs msgs2
-      | BetreeMessageUpsert ufs =>
-        msgs1 <- betree_node_lookup_first_message_after_key_fwd n key msgs0;
+          betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+            Betree_Message_Insert v);
+        betree_Node_lookup_first_message_for_key_back n key msgs msgs2
+      | Betree_Message_Upsert ufs =>
+        msgs1 <- betree_Node_lookup_first_message_after_key n key msgs0;
         msgs2 <-
-          betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs1 (key,
-            BetreeMessageUpsert s);
+          betree_List_push_front (u64 * betree_Message_t) msgs1 (key,
+            Betree_Message_Upsert s);
         msgs3 <-
-          betree_node_lookup_first_message_after_key_back n key msgs0 msgs2;
-        betree_node_lookup_first_message_for_key_back n key msgs msgs3
+          betree_Node_lookup_first_message_after_key_back n key msgs0 msgs2;
+        betree_Node_lookup_first_message_for_key_back n key msgs msgs3
       end
     end
   else (
     msgs1 <-
-      betree_list_push_front_fwd_back (u64 * Betree_message_t) msgs0 (key,
-        new_msg);
-    betree_node_lookup_first_message_for_key_back n key msgs msgs1)
+      betree_List_push_front (u64 * betree_Message_t) msgs0 (key, new_msg);
+    betree_Node_lookup_first_message_for_key_back n key msgs msgs1)
 .
 
 (** [betree_main::betree::Node::{5}::apply_messages_to_internal]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint betree_node_apply_messages_to_internal_fwd_back
-  (n : nat) (msgs : Betree_list_t (u64 * Betree_message_t))
-  (new_msgs : Betree_list_t (u64 * Betree_message_t)) :
-  result (Betree_list_t (u64 * Betree_message_t))
+Fixpoint betree_Node_apply_messages_to_internal
+  (n : nat) (msgs : betree_List_t (u64 * betree_Message_t))
+  (new_msgs : betree_List_t (u64 * betree_Message_t)) :
+  result (betree_List_t (u64 * betree_Message_t))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match new_msgs with
-    | BetreeListCons new_msg new_msgs_tl =>
+    | Betree_List_Cons new_msg new_msgs_tl =>
       let (i, m) := new_msg in
-      msgs0 <- betree_node_apply_to_internal_fwd_back n0 msgs i m;
-      betree_node_apply_messages_to_internal_fwd_back n0 msgs0 new_msgs_tl
-    | BetreeListNil => Return msgs
+      msgs0 <- betree_Node_apply_to_internal n0 msgs i m;
+      betree_Node_apply_messages_to_internal n0 msgs0 new_msgs_tl
+    | Betree_List_Nil => Return msgs
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: forward function *)
-Fixpoint betree_node_lookup_mut_in_bindings_fwd
-  (n : nat) (key : u64) (bindings : Betree_list_t (u64 * u64)) :
-  result (Betree_list_t (u64 * u64))
+Fixpoint betree_Node_lookup_mut_in_bindings
+  (n : nat) (key : u64) (bindings : betree_List_t (u64 * u64)) :
+  result (betree_List_t (u64 * u64))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match bindings with
-    | BetreeListCons hd tl =>
+    | Betree_List_Cons hd tl =>
       let (i, i0) := hd in
       if i s>= key
-      then Return (BetreeListCons (i, i0) tl)
-      else betree_node_lookup_mut_in_bindings_fwd n0 key tl
-    | BetreeListNil => Return BetreeListNil
+      then Return (Betree_List_Cons (i, i0) tl)
+      else betree_Node_lookup_mut_in_bindings n0 key tl
+    | Betree_List_Nil => Return Betree_List_Nil
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::lookup_mut_in_bindings]: backward function 0 *)
-Fixpoint betree_node_lookup_mut_in_bindings_back
-  (n : nat) (key : u64) (bindings : Betree_list_t (u64 * u64))
-  (ret : Betree_list_t (u64 * u64)) :
-  result (Betree_list_t (u64 * u64))
+Fixpoint betree_Node_lookup_mut_in_bindings_back
+  (n : nat) (key : u64) (bindings : betree_List_t (u64 * u64))
+  (ret : betree_List_t (u64 * u64)) :
+  result (betree_List_t (u64 * u64))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match bindings with
-    | BetreeListCons hd tl =>
+    | Betree_List_Cons hd tl =>
       let (i, i0) := hd in
       if i s>= key
       then Return ret
       else (
-        tl0 <- betree_node_lookup_mut_in_bindings_back n0 key tl ret;
-        Return (BetreeListCons (i, i0) tl0))
-    | BetreeListNil => Return ret
+        tl0 <- betree_Node_lookup_mut_in_bindings_back n0 key tl ret;
+        Return (Betree_List_Cons (i, i0) tl0))
+    | Betree_List_Nil => Return ret
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::apply_to_leaf]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition betree_node_apply_to_leaf_fwd_back
-  (n : nat) (bindings : Betree_list_t (u64 * u64)) (key : u64)
-  (new_msg : Betree_message_t) :
-  result (Betree_list_t (u64 * u64))
+Definition betree_Node_apply_to_leaf
+  (n : nat) (bindings : betree_List_t (u64 * u64)) (key : u64)
+  (new_msg : betree_Message_t) :
+  result (betree_List_t (u64 * u64))
   :=
-  bindings0 <- betree_node_lookup_mut_in_bindings_fwd n key bindings;
-  b <- betree_list_head_has_key_fwd u64 bindings0 key;
+  bindings0 <- betree_Node_lookup_mut_in_bindings n key bindings;
+  b <- betree_List_head_has_key u64 bindings0 key;
   if b
   then (
-    hd <- betree_list_pop_front_fwd (u64 * u64) bindings0;
+    hd <- betree_List_pop_front (u64 * u64) bindings0;
     match new_msg with
-    | BetreeMessageInsert v =>
-      bindings1 <- betree_list_pop_front_back (u64 * u64) bindings0;
-      bindings2 <-
-        betree_list_push_front_fwd_back (u64 * u64) bindings1 (key, v);
-      betree_node_lookup_mut_in_bindings_back n key bindings bindings2
-    | BetreeMessageDelete =>
-      bindings1 <- betree_list_pop_front_back (u64 * u64) bindings0;
-      betree_node_lookup_mut_in_bindings_back n key bindings bindings1
-    | BetreeMessageUpsert s =>
+    | Betree_Message_Insert v =>
+      bindings1 <- betree_List_pop_front_back (u64 * u64) bindings0;
+      bindings2 <- betree_List_push_front (u64 * u64) bindings1 (key, v);
+      betree_Node_lookup_mut_in_bindings_back n key bindings bindings2
+    | Betree_Message_Delete =>
+      bindings1 <- betree_List_pop_front_back (u64 * u64) bindings0;
+      betree_Node_lookup_mut_in_bindings_back n key bindings bindings1
+    | Betree_Message_Upsert s =>
       let (_, i) := hd in
-      v <- betree_upsert_update_fwd (Some i) s;
-      bindings1 <- betree_list_pop_front_back (u64 * u64) bindings0;
-      bindings2 <-
-        betree_list_push_front_fwd_back (u64 * u64) bindings1 (key, v);
-      betree_node_lookup_mut_in_bindings_back n key bindings bindings2
+      v <- betree_upsert_update (Some i) s;
+      bindings1 <- betree_List_pop_front_back (u64 * u64) bindings0;
+      bindings2 <- betree_List_push_front (u64 * u64) bindings1 (key, v);
+      betree_Node_lookup_mut_in_bindings_back n key bindings bindings2
     end)
   else
     match new_msg with
-    | BetreeMessageInsert v =>
-      bindings1 <-
-        betree_list_push_front_fwd_back (u64 * u64) bindings0 (key, v);
-      betree_node_lookup_mut_in_bindings_back n key bindings bindings1
-    | BetreeMessageDelete =>
-      betree_node_lookup_mut_in_bindings_back n key bindings bindings0
-    | BetreeMessageUpsert s =>
-      v <- betree_upsert_update_fwd None s;
-      bindings1 <-
-        betree_list_push_front_fwd_back (u64 * u64) bindings0 (key, v);
-      betree_node_lookup_mut_in_bindings_back n key bindings bindings1
+    | Betree_Message_Insert v =>
+      bindings1 <- betree_List_push_front (u64 * u64) bindings0 (key, v);
+      betree_Node_lookup_mut_in_bindings_back n key bindings bindings1
+    | Betree_Message_Delete =>
+      betree_Node_lookup_mut_in_bindings_back n key bindings bindings0
+    | Betree_Message_Upsert s =>
+      v <- betree_upsert_update None s;
+      bindings1 <- betree_List_push_front (u64 * u64) bindings0 (key, v);
+      betree_Node_lookup_mut_in_bindings_back n key bindings bindings1
     end
 .
 
 (** [betree_main::betree::Node::{5}::apply_messages_to_leaf]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint betree_node_apply_messages_to_leaf_fwd_back
-  (n : nat) (bindings : Betree_list_t (u64 * u64))
-  (new_msgs : Betree_list_t (u64 * Betree_message_t)) :
-  result (Betree_list_t (u64 * u64))
+Fixpoint betree_Node_apply_messages_to_leaf
+  (n : nat) (bindings : betree_List_t (u64 * u64))
+  (new_msgs : betree_List_t (u64 * betree_Message_t)) :
+  result (betree_List_t (u64 * u64))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match new_msgs with
-    | BetreeListCons new_msg new_msgs_tl =>
+    | Betree_List_Cons new_msg new_msgs_tl =>
       let (i, m) := new_msg in
-      bindings0 <- betree_node_apply_to_leaf_fwd_back n0 bindings i m;
-      betree_node_apply_messages_to_leaf_fwd_back n0 bindings0 new_msgs_tl
-    | BetreeListNil => Return bindings
+      bindings0 <- betree_Node_apply_to_leaf n0 bindings i m;
+      betree_Node_apply_messages_to_leaf n0 bindings0 new_msgs_tl
+    | Betree_List_Nil => Return bindings
     end
   end
 .
 
 (** [betree_main::betree::Internal::{4}::flush]: forward function *)
-Fixpoint betree_internal_flush_fwd
-  (n : nat) (self : Betree_internal_t) (params : Betree_params_t)
-  (node_id_cnt : Betree_node_id_counter_t)
-  (content : Betree_list_t (u64 * Betree_message_t)) (st : state) :
-  result (state * (Betree_list_t (u64 * Betree_message_t)))
+Fixpoint betree_Internal_flush
+  (n : nat) (self : betree_Internal_t) (params : betree_Params_t)
+  (node_id_cnt : betree_NodeIdCounter_t)
+  (content : betree_List_t (u64 * betree_Message_t)) (st : state) :
+  result (state * (betree_List_t (u64 * betree_Message_t)))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     p <-
-      betree_list_partition_at_pivot_fwd Betree_message_t n0 content
-        self.(Betree_internal_pivot);
+      betree_List_partition_at_pivot betree_Message_t n0 content
+        self.(betree_Internal_pivot);
     let (msgs_left, msgs_right) := p in
-    len_left <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_left;
-    if len_left s>= params.(Betree_params_min_flush_size)
+    len_left <- betree_List_len (u64 * betree_Message_t) n0 msgs_left;
+    if len_left s>= params.(betree_Params_min_flush_size)
     then (
       p0 <-
-        betree_node_apply_messages_fwd n0 self.(Betree_internal_left) params
+        betree_Node_apply_messages n0 self.(betree_Internal_left) params
           node_id_cnt msgs_left st;
       let (st0, _) := p0 in
       p1 <-
-        betree_node_apply_messages_back n0 self.(Betree_internal_left) params
+        betree_Node_apply_messages_back n0 self.(betree_Internal_left) params
           node_id_cnt msgs_left st;
       let (_, node_id_cnt0) := p1 in
-      len_right <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_right;
-      if len_right s>= params.(Betree_params_min_flush_size)
+      len_right <- betree_List_len (u64 * betree_Message_t) n0 msgs_right;
+      if len_right s>= params.(betree_Params_min_flush_size)
       then (
         p2 <-
-          betree_node_apply_messages_fwd n0 self.(Betree_internal_right) params
+          betree_Node_apply_messages n0 self.(betree_Internal_right) params
             node_id_cnt0 msgs_right st0;
         let (st1, _) := p2 in
         _ <-
-          betree_node_apply_messages_back n0 self.(Betree_internal_right)
+          betree_Node_apply_messages_back n0 self.(betree_Internal_right)
             params node_id_cnt0 msgs_right st0;
-        Return (st1, BetreeListNil))
+        Return (st1, Betree_List_Nil))
       else Return (st0, msgs_right))
     else (
       p0 <-
-        betree_node_apply_messages_fwd n0 self.(Betree_internal_right) params
+        betree_Node_apply_messages n0 self.(betree_Internal_right) params
           node_id_cnt msgs_right st;
       let (st0, _) := p0 in
       _ <-
-        betree_node_apply_messages_back n0 self.(Betree_internal_right) params
+        betree_Node_apply_messages_back n0 self.(betree_Internal_right) params
           node_id_cnt msgs_right st;
       Return (st0, msgs_left))
   end
 
 (** [betree_main::betree::Internal::{4}::flush]: backward function 0 *)
-with betree_internal_flush_back
-  (n : nat) (self : Betree_internal_t) (params : Betree_params_t)
-  (node_id_cnt : Betree_node_id_counter_t)
-  (content : Betree_list_t (u64 * Betree_message_t)) (st : state) :
-  result (Betree_internal_t * Betree_node_id_counter_t)
+with betree_Internal_flush_back
+  (n : nat) (self : betree_Internal_t) (params : betree_Params_t)
+  (node_id_cnt : betree_NodeIdCounter_t)
+  (content : betree_List_t (u64 * betree_Message_t)) (st : state) :
+  result (betree_Internal_t * betree_NodeIdCounter_t)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     p <-
-      betree_list_partition_at_pivot_fwd Betree_message_t n0 content
-        self.(Betree_internal_pivot);
+      betree_List_partition_at_pivot betree_Message_t n0 content
+        self.(betree_Internal_pivot);
     let (msgs_left, msgs_right) := p in
-    len_left <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_left;
-    if len_left s>= params.(Betree_params_min_flush_size)
+    len_left <- betree_List_len (u64 * betree_Message_t) n0 msgs_left;
+    if len_left s>= params.(betree_Params_min_flush_size)
     then (
       p0 <-
-        betree_node_apply_messages_fwd n0 self.(Betree_internal_left) params
+        betree_Node_apply_messages n0 self.(betree_Internal_left) params
           node_id_cnt msgs_left st;
       let (st0, _) := p0 in
       p1 <-
-        betree_node_apply_messages_back n0 self.(Betree_internal_left) params
+        betree_Node_apply_messages_back n0 self.(betree_Internal_left) params
           node_id_cnt msgs_left st;
       let (n1, node_id_cnt0) := p1 in
-      len_right <- betree_list_len_fwd (u64 * Betree_message_t) n0 msgs_right;
-      if len_right s>= params.(Betree_params_min_flush_size)
+      len_right <- betree_List_len (u64 * betree_Message_t) n0 msgs_right;
+      if len_right s>= params.(betree_Params_min_flush_size)
       then (
         p2 <-
-          betree_node_apply_messages_back n0 self.(Betree_internal_right)
+          betree_Node_apply_messages_back n0 self.(betree_Internal_right)
             params node_id_cnt0 msgs_right st0;
         let (n2, node_id_cnt1) := p2 in
-        Return (mkBetree_internal_t self.(Betree_internal_id)
-          self.(Betree_internal_pivot) n1 n2, node_id_cnt1))
+        Return (mkbetree_Internal_t self.(betree_Internal_id)
+          self.(betree_Internal_pivot) n1 n2, node_id_cnt1))
       else
-        Return (mkBetree_internal_t self.(Betree_internal_id)
-          self.(Betree_internal_pivot) n1 self.(Betree_internal_right),
+        Return (mkbetree_Internal_t self.(betree_Internal_id)
+          self.(betree_Internal_pivot) n1 self.(betree_Internal_right),
           node_id_cnt0))
     else (
       p0 <-
-        betree_node_apply_messages_back n0 self.(Betree_internal_right) params
+        betree_Node_apply_messages_back n0 self.(betree_Internal_right) params
           node_id_cnt msgs_right st;
       let (n1, node_id_cnt0) := p0 in
-      Return (mkBetree_internal_t self.(Betree_internal_id)
-        self.(Betree_internal_pivot) self.(Betree_internal_left) n1,
+      Return (mkbetree_Internal_t self.(betree_Internal_id)
+        self.(betree_Internal_pivot) self.(betree_Internal_left) n1,
         node_id_cnt0))
   end
 
 (** [betree_main::betree::Node::{5}::apply_messages]: forward function *)
-with betree_node_apply_messages_fwd
-  (n : nat) (self : Betree_node_t) (params : Betree_params_t)
-  (node_id_cnt : Betree_node_id_counter_t)
-  (msgs : Betree_list_t (u64 * Betree_message_t)) (st : state) :
+with betree_Node_apply_messages
+  (n : nat) (self : betree_Node_t) (params : betree_Params_t)
+  (node_id_cnt : betree_NodeIdCounter_t)
+  (msgs : betree_List_t (u64 * betree_Message_t)) (st : state) :
   result (state * unit)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match self with
-    | BetreeNodeInternal node =>
-      p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+    | Betree_Node_Internal node =>
+      p <- betree_load_internal_node node.(betree_Internal_id) st;
       let (st0, content) := p in
-      content0 <-
-        betree_node_apply_messages_to_internal_fwd_back n0 content msgs;
-      num_msgs <- betree_list_len_fwd (u64 * Betree_message_t) n0 content0;
-      if num_msgs s>= params.(Betree_params_min_flush_size)
+      content0 <- betree_Node_apply_messages_to_internal n0 content msgs;
+      num_msgs <- betree_List_len (u64 * betree_Message_t) n0 content0;
+      if num_msgs s>= params.(betree_Params_min_flush_size)
       then (
-        p0 <-
-          betree_internal_flush_fwd n0 node params node_id_cnt content0 st0;
+        p0 <- betree_Internal_flush n0 node params node_id_cnt content0 st0;
         let (st1, content1) := p0 in
         p1 <-
-          betree_internal_flush_back n0 node params node_id_cnt content0 st0;
+          betree_Internal_flush_back n0 node params node_id_cnt content0 st0;
         let (node0, _) := p1 in
         p2 <-
-          betree_store_internal_node_fwd node0.(Betree_internal_id) content1
-            st1;
+          betree_store_internal_node node0.(betree_Internal_id) content1 st1;
         let (st2, _) := p2 in
         Return (st2, tt))
       else (
         p0 <-
-          betree_store_internal_node_fwd node.(Betree_internal_id) content0 st0;
+          betree_store_internal_node node.(betree_Internal_id) content0 st0;
         let (st1, _) := p0 in
         Return (st1, tt))
-    | BetreeNodeLeaf node =>
-      p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+    | Betree_Node_Leaf node =>
+      p <- betree_load_leaf_node node.(betree_Leaf_id) st;
       let (st0, content) := p in
-      content0 <- betree_node_apply_messages_to_leaf_fwd_back n0 content msgs;
-      len <- betree_list_len_fwd (u64 * u64) n0 content0;
-      i <- u64_mul 2%u64 params.(Betree_params_split_size);
+      content0 <- betree_Node_apply_messages_to_leaf n0 content msgs;
+      len <- betree_List_len (u64 * u64) n0 content0;
+      i <- u64_mul 2%u64 params.(betree_Params_split_size);
       if len s>= i
       then (
-        p0 <- betree_leaf_split_fwd n0 node content0 params node_id_cnt st0;
+        p0 <- betree_Leaf_split n0 node content0 params node_id_cnt st0;
         let (st1, _) := p0 in
-        p1 <-
-          betree_store_leaf_node_fwd node.(Betree_leaf_id) BetreeListNil st1;
+        p1 <- betree_store_leaf_node node.(betree_Leaf_id) Betree_List_Nil st1;
         let (st2, _) := p1 in
         Return (st2, tt))
       else (
-        p0 <- betree_store_leaf_node_fwd node.(Betree_leaf_id) content0 st0;
+        p0 <- betree_store_leaf_node node.(betree_Leaf_id) content0 st0;
         let (st1, _) := p0 in
         Return (st1, tt))
     end
   end
 
 (** [betree_main::betree::Node::{5}::apply_messages]: backward function 0 *)
-with betree_node_apply_messages_back
-  (n : nat) (self : Betree_node_t) (params : Betree_params_t)
-  (node_id_cnt : Betree_node_id_counter_t)
-  (msgs : Betree_list_t (u64 * Betree_message_t)) (st : state) :
-  result (Betree_node_t * Betree_node_id_counter_t)
+with betree_Node_apply_messages_back
+  (n : nat) (self : betree_Node_t) (params : betree_Params_t)
+  (node_id_cnt : betree_NodeIdCounter_t)
+  (msgs : betree_List_t (u64 * betree_Message_t)) (st : state) :
+  result (betree_Node_t * betree_NodeIdCounter_t)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match self with
-    | BetreeNodeInternal node =>
-      p <- betree_load_internal_node_fwd node.(Betree_internal_id) st;
+    | Betree_Node_Internal node =>
+      p <- betree_load_internal_node node.(betree_Internal_id) st;
       let (st0, content) := p in
-      content0 <-
-        betree_node_apply_messages_to_internal_fwd_back n0 content msgs;
-      num_msgs <- betree_list_len_fwd (u64 * Betree_message_t) n0 content0;
-      if num_msgs s>= params.(Betree_params_min_flush_size)
+      content0 <- betree_Node_apply_messages_to_internal n0 content msgs;
+      num_msgs <- betree_List_len (u64 * betree_Message_t) n0 content0;
+      if num_msgs s>= params.(betree_Params_min_flush_size)
       then (
-        p0 <-
-          betree_internal_flush_fwd n0 node params node_id_cnt content0 st0;
+        p0 <- betree_Internal_flush n0 node params node_id_cnt content0 st0;
         let (st1, content1) := p0 in
         p1 <-
-          betree_internal_flush_back n0 node params node_id_cnt content0 st0;
+          betree_Internal_flush_back n0 node params node_id_cnt content0 st0;
         let (node0, node_id_cnt0) := p1 in
         _ <-
-          betree_store_internal_node_fwd node0.(Betree_internal_id) content1
-            st1;
-        Return (BetreeNodeInternal node0, node_id_cnt0))
+          betree_store_internal_node node0.(betree_Internal_id) content1 st1;
+        Return (Betree_Node_Internal node0, node_id_cnt0))
       else (
-        _ <-
-          betree_store_internal_node_fwd node.(Betree_internal_id) content0 st0;
-        Return (BetreeNodeInternal node, node_id_cnt))
-    | BetreeNodeLeaf node =>
-      p <- betree_load_leaf_node_fwd node.(Betree_leaf_id) st;
+        _ <- betree_store_internal_node node.(betree_Internal_id) content0 st0;
+        Return (Betree_Node_Internal node, node_id_cnt))
+    | Betree_Node_Leaf node =>
+      p <- betree_load_leaf_node node.(betree_Leaf_id) st;
       let (st0, content) := p in
-      content0 <- betree_node_apply_messages_to_leaf_fwd_back n0 content msgs;
-      len <- betree_list_len_fwd (u64 * u64) n0 content0;
-      i <- u64_mul 2%u64 params.(Betree_params_split_size);
+      content0 <- betree_Node_apply_messages_to_leaf n0 content msgs;
+      len <- betree_List_len (u64 * u64) n0 content0;
+      i <- u64_mul 2%u64 params.(betree_Params_split_size);
       if len s>= i
       then (
-        p0 <- betree_leaf_split_fwd n0 node content0 params node_id_cnt st0;
+        p0 <- betree_Leaf_split n0 node content0 params node_id_cnt st0;
         let (st1, new_node) := p0 in
-        _ <-
-          betree_store_leaf_node_fwd node.(Betree_leaf_id) BetreeListNil st1;
+        _ <- betree_store_leaf_node node.(betree_Leaf_id) Betree_List_Nil st1;
         node_id_cnt0 <-
-          betree_leaf_split_back n0 node content0 params node_id_cnt st0;
-        Return (BetreeNodeInternal new_node, node_id_cnt0))
+          betree_Leaf_split_back n0 node content0 params node_id_cnt st0;
+        Return (Betree_Node_Internal new_node, node_id_cnt0))
       else (
-        _ <- betree_store_leaf_node_fwd node.(Betree_leaf_id) content0 st0;
-        Return (BetreeNodeLeaf
-          {| Betree_leaf_id := node.(Betree_leaf_id); Betree_leaf_size := len
+        _ <- betree_store_leaf_node node.(betree_Leaf_id) content0 st0;
+        Return (Betree_Node_Leaf
+          {| betree_Leaf_id := node.(betree_Leaf_id); betree_Leaf_size := len
           |}, node_id_cnt))
     end
   end
 .
 
 (** [betree_main::betree::Node::{5}::apply]: forward function *)
-Definition betree_node_apply_fwd
-  (n : nat) (self : Betree_node_t) (params : Betree_params_t)
-  (node_id_cnt : Betree_node_id_counter_t) (key : u64)
-  (new_msg : Betree_message_t) (st : state) :
+Definition betree_Node_apply
+  (n : nat) (self : betree_Node_t) (params : betree_Params_t)
+  (node_id_cnt : betree_NodeIdCounter_t) (key : u64)
+  (new_msg : betree_Message_t) (st : state) :
   result (state * unit)
   :=
-  let l := BetreeListNil in
+  let l := Betree_List_Nil in
   p <-
-    betree_node_apply_messages_fwd n self params node_id_cnt (BetreeListCons
+    betree_Node_apply_messages n self params node_id_cnt (Betree_List_Cons
       (key, new_msg) l) st;
   let (st0, _) := p in
   _ <-
-    betree_node_apply_messages_back n self params node_id_cnt (BetreeListCons
+    betree_Node_apply_messages_back n self params node_id_cnt (Betree_List_Cons
       (key, new_msg) l) st;
   Return (st0, tt)
 .
 
 (** [betree_main::betree::Node::{5}::apply]: backward function 0 *)
-Definition betree_node_apply_back
-  (n : nat) (self : Betree_node_t) (params : Betree_params_t)
-  (node_id_cnt : Betree_node_id_counter_t) (key : u64)
-  (new_msg : Betree_message_t) (st : state) :
-  result (Betree_node_t * Betree_node_id_counter_t)
+Definition betree_Node_apply_back
+  (n : nat) (self : betree_Node_t) (params : betree_Params_t)
+  (node_id_cnt : betree_NodeIdCounter_t) (key : u64)
+  (new_msg : betree_Message_t) (st : state) :
+  result (betree_Node_t * betree_NodeIdCounter_t)
   :=
-  let l := BetreeListNil in
-  betree_node_apply_messages_back n self params node_id_cnt (BetreeListCons
+  let l := Betree_List_Nil in
+  betree_Node_apply_messages_back n self params node_id_cnt (Betree_List_Cons
     (key, new_msg) l) st
 .
 
 (** [betree_main::betree::BeTree::{6}::new]: forward function *)
-Definition betree_be_tree_new_fwd
+Definition betree_BeTree_new
   (min_flush_size : u64) (split_size : u64) (st : state) :
-  result (state * Betree_be_tree_t)
+  result (state * betree_BeTree_t)
   :=
-  node_id_cnt <- betree_node_id_counter_new_fwd;
-  id <- betree_node_id_counter_fresh_id_fwd node_id_cnt;
-  p <- betree_store_leaf_node_fwd id BetreeListNil st;
+  node_id_cnt <- betree_NodeIdCounter_new;
+  id <- betree_NodeIdCounter_fresh_id node_id_cnt;
+  p <- betree_store_leaf_node id Betree_List_Nil st;
   let (st0, _) := p in
-  node_id_cnt0 <- betree_node_id_counter_fresh_id_back node_id_cnt;
+  node_id_cnt0 <- betree_NodeIdCounter_fresh_id_back node_id_cnt;
   Return (st0,
     {|
-      Betree_be_tree_params :=
+      betree_BeTree_params :=
         {|
-          Betree_params_min_flush_size := min_flush_size;
-          Betree_params_split_size := split_size
+          betree_Params_min_flush_size := min_flush_size;
+          betree_Params_split_size := split_size
         |};
-      Betree_be_tree_node_id_cnt := node_id_cnt0;
-      Betree_be_tree_root :=
-        (BetreeNodeLeaf {| Betree_leaf_id := id; Betree_leaf_size := 0%u64 |})
+      betree_BeTree_node_id_cnt := node_id_cnt0;
+      betree_BeTree_root :=
+        (Betree_Node_Leaf
+          {| betree_Leaf_id := id; betree_Leaf_size := 0%u64 |})
     |})
 .
 
 (** [betree_main::betree::BeTree::{6}::apply]: forward function *)
-Definition betree_be_tree_apply_fwd
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (msg : Betree_message_t)
+Definition betree_BeTree_apply
+  (n : nat) (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t)
   (st : state) :
   result (state * unit)
   :=
   p <-
-    betree_node_apply_fwd n self.(Betree_be_tree_root)
-      self.(Betree_be_tree_params) self.(Betree_be_tree_node_id_cnt) key msg st;
+    betree_Node_apply n self.(betree_BeTree_root) self.(betree_BeTree_params)
+      self.(betree_BeTree_node_id_cnt) key msg st;
   let (st0, _) := p in
   _ <-
-    betree_node_apply_back n self.(Betree_be_tree_root)
-      self.(Betree_be_tree_params) self.(Betree_be_tree_node_id_cnt) key msg st;
+    betree_Node_apply_back n self.(betree_BeTree_root)
+      self.(betree_BeTree_params) self.(betree_BeTree_node_id_cnt) key msg st;
   Return (st0, tt)
 .
 
 (** [betree_main::betree::BeTree::{6}::apply]: backward function 0 *)
-Definition betree_be_tree_apply_back
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (msg : Betree_message_t)
+Definition betree_BeTree_apply_back
+  (n : nat) (self : betree_BeTree_t) (key : u64) (msg : betree_Message_t)
   (st : state) :
-  result Betree_be_tree_t
+  result betree_BeTree_t
   :=
   p <-
-    betree_node_apply_back n self.(Betree_be_tree_root)
-      self.(Betree_be_tree_params) self.(Betree_be_tree_node_id_cnt) key msg st;
+    betree_Node_apply_back n self.(betree_BeTree_root)
+      self.(betree_BeTree_params) self.(betree_BeTree_node_id_cnt) key msg st;
   let (n0, nic) := p in
   Return
     {|
-      Betree_be_tree_params := self.(Betree_be_tree_params);
-      Betree_be_tree_node_id_cnt := nic;
-      Betree_be_tree_root := n0
+      betree_BeTree_params := self.(betree_BeTree_params);
+      betree_BeTree_node_id_cnt := nic;
+      betree_BeTree_root := n0
     |}
 .
 
 (** [betree_main::betree::BeTree::{6}::insert]: forward function *)
-Definition betree_be_tree_insert_fwd
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (value : u64) (st : state) :
+Definition betree_BeTree_insert
+  (n : nat) (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) :
   result (state * unit)
   :=
-  p <- betree_be_tree_apply_fwd n self key (BetreeMessageInsert value) st;
+  p <- betree_BeTree_apply n self key (Betree_Message_Insert value) st;
   let (st0, _) := p in
-  _ <- betree_be_tree_apply_back n self key (BetreeMessageInsert value) st;
+  _ <- betree_BeTree_apply_back n self key (Betree_Message_Insert value) st;
   Return (st0, tt)
 .
 
 (** [betree_main::betree::BeTree::{6}::insert]: backward function 0 *)
-Definition betree_be_tree_insert_back
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (value : u64) (st : state) :
-  result Betree_be_tree_t
+Definition betree_BeTree_insert_back
+  (n : nat) (self : betree_BeTree_t) (key : u64) (value : u64) (st : state) :
+  result betree_BeTree_t
   :=
-  betree_be_tree_apply_back n self key (BetreeMessageInsert value) st
+  betree_BeTree_apply_back n self key (Betree_Message_Insert value) st
 .
 
 (** [betree_main::betree::BeTree::{6}::delete]: forward function *)
-Definition betree_be_tree_delete_fwd
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
+Definition betree_BeTree_delete
+  (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
   result (state * unit)
   :=
-  p <- betree_be_tree_apply_fwd n self key BetreeMessageDelete st;
+  p <- betree_BeTree_apply n self key Betree_Message_Delete st;
   let (st0, _) := p in
-  _ <- betree_be_tree_apply_back n self key BetreeMessageDelete st;
+  _ <- betree_BeTree_apply_back n self key Betree_Message_Delete st;
   Return (st0, tt)
 .
 
 (** [betree_main::betree::BeTree::{6}::delete]: backward function 0 *)
-Definition betree_be_tree_delete_back
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
-  result Betree_be_tree_t
+Definition betree_BeTree_delete_back
+  (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
+  result betree_BeTree_t
   :=
-  betree_be_tree_apply_back n self key BetreeMessageDelete st
+  betree_BeTree_apply_back n self key Betree_Message_Delete st
 .
 
 (** [betree_main::betree::BeTree::{6}::upsert]: forward function *)
-Definition betree_be_tree_upsert_fwd
-  (n : nat) (self : Betree_be_tree_t) (key : u64)
-  (upd : Betree_upsert_fun_state_t) (st : state) :
+Definition betree_BeTree_upsert
+  (n : nat) (self : betree_BeTree_t) (key : u64)
+  (upd : betree_UpsertFunState_t) (st : state) :
   result (state * unit)
   :=
-  p <- betree_be_tree_apply_fwd n self key (BetreeMessageUpsert upd) st;
+  p <- betree_BeTree_apply n self key (Betree_Message_Upsert upd) st;
   let (st0, _) := p in
-  _ <- betree_be_tree_apply_back n self key (BetreeMessageUpsert upd) st;
+  _ <- betree_BeTree_apply_back n self key (Betree_Message_Upsert upd) st;
   Return (st0, tt)
 .
 
 (** [betree_main::betree::BeTree::{6}::upsert]: backward function 0 *)
-Definition betree_be_tree_upsert_back
-  (n : nat) (self : Betree_be_tree_t) (key : u64)
-  (upd : Betree_upsert_fun_state_t) (st : state) :
-  result Betree_be_tree_t
+Definition betree_BeTree_upsert_back
+  (n : nat) (self : betree_BeTree_t) (key : u64)
+  (upd : betree_UpsertFunState_t) (st : state) :
+  result betree_BeTree_t
   :=
-  betree_be_tree_apply_back n self key (BetreeMessageUpsert upd) st
+  betree_BeTree_apply_back n self key (Betree_Message_Upsert upd) st
 .
 
 (** [betree_main::betree::BeTree::{6}::lookup]: forward function *)
-Definition betree_be_tree_lookup_fwd
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
+Definition betree_BeTree_lookup
+  (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
   result (state * (option u64))
   :=
-  betree_node_lookup_fwd n self.(Betree_be_tree_root) key st
+  betree_Node_lookup n self.(betree_BeTree_root) key st
 .
 
 (** [betree_main::betree::BeTree::{6}::lookup]: backward function 0 *)
-Definition betree_be_tree_lookup_back
-  (n : nat) (self : Betree_be_tree_t) (key : u64) (st : state) :
-  result Betree_be_tree_t
+Definition betree_BeTree_lookup_back
+  (n : nat) (self : betree_BeTree_t) (key : u64) (st : state) :
+  result betree_BeTree_t
   :=
-  n0 <- betree_node_lookup_back n self.(Betree_be_tree_root) key st;
+  n0 <- betree_Node_lookup_back n self.(betree_BeTree_root) key st;
   Return
     {|
-      Betree_be_tree_params := self.(Betree_be_tree_params);
-      Betree_be_tree_node_id_cnt := self.(Betree_be_tree_node_id_cnt);
-      Betree_be_tree_root := n0
+      betree_BeTree_params := self.(betree_BeTree_params);
+      betree_BeTree_node_id_cnt := self.(betree_BeTree_node_id_cnt);
+      betree_BeTree_root := n0
     |}
 .
 
 (** [betree_main::main]: forward function *)
-Definition main_fwd : result unit :=
+Definition main : result unit :=
   Return tt.
 
 (** Unit test for [betree_main::main] *)
-Check (main_fwd )%return.
+Check (main )%return.
 
 End BetreeMain_Funs .
diff --git a/tests/coq/betree/BetreeMain_Opaque.v b/tests/coq/betree/BetreeMain_Opaque.v
index ecd81b9d..eade90de 100644
--- a/tests/coq/betree/BetreeMain_Opaque.v
+++ b/tests/coq/betree/BetreeMain_Opaque.v
@@ -11,29 +11,29 @@ Import BetreeMain_Types.
 Module BetreeMain_Opaque.
 
 (** [betree_main::betree_utils::load_internal_node]: forward function *)
-Axiom betree_utils_load_internal_node_fwd
-  : u64 -> state -> result (state * (Betree_list_t (u64 * Betree_message_t)))
+Axiom betree_utils_load_internal_node
+  : u64 -> state -> result (state * (betree_List_t (u64 * betree_Message_t)))
 .
 
 (** [betree_main::betree_utils::store_internal_node]: forward function *)
-Axiom betree_utils_store_internal_node_fwd
+Axiom betree_utils_store_internal_node
   :
-  u64 -> Betree_list_t (u64 * Betree_message_t) -> state -> result (state *
+  u64 -> betree_List_t (u64 * betree_Message_t) -> state -> result (state *
     unit)
 .
 
 (** [betree_main::betree_utils::load_leaf_node]: forward function *)
-Axiom betree_utils_load_leaf_node_fwd
-  : u64 -> state -> result (state * (Betree_list_t (u64 * u64)))
+Axiom betree_utils_load_leaf_node
+  : u64 -> state -> result (state * (betree_List_t (u64 * u64)))
 .
 
 (** [betree_main::betree_utils::store_leaf_node]: forward function *)
-Axiom betree_utils_store_leaf_node_fwd
-  : u64 -> Betree_list_t (u64 * u64) -> state -> result (state * unit)
+Axiom betree_utils_store_leaf_node
+  : u64 -> betree_List_t (u64 * u64) -> state -> result (state * unit)
 .
 
 (** [core::option::Option::{0}::unwrap]: forward function *)
-Axiom core_option_option_unwrap_fwd :
+Axiom core_option_Option_unwrap :
   forall(T : Type), option T -> state -> result (state * T)
 .
 
diff --git a/tests/coq/betree/BetreeMain_Types.v b/tests/coq/betree/BetreeMain_Types.v
index 4a4e75aa..ee26622e 100644
--- a/tests/coq/betree/BetreeMain_Types.v
+++ b/tests/coq/betree/BetreeMain_Types.v
@@ -9,98 +9,98 @@ Local Open Scope Primitives_scope.
 Module BetreeMain_Types.
 
 (** [betree_main::betree::List] *)
-Inductive Betree_list_t (T : Type) :=
-| BetreeListCons : T -> Betree_list_t T -> Betree_list_t T
-| BetreeListNil : Betree_list_t T
+Inductive betree_List_t (T : Type) :=
+| Betree_List_Cons : T -> betree_List_t T -> betree_List_t T
+| Betree_List_Nil : betree_List_t T
 .
 
-Arguments BetreeListCons {T} _ _.
-Arguments BetreeListNil {T}.
+Arguments Betree_List_Cons {T} _ _.
+Arguments Betree_List_Nil {T}.
 
 (** [betree_main::betree::UpsertFunState] *)
-Inductive Betree_upsert_fun_state_t :=
-| BetreeUpsertFunStateAdd : u64 -> Betree_upsert_fun_state_t
-| BetreeUpsertFunStateSub : u64 -> Betree_upsert_fun_state_t
+Inductive betree_UpsertFunState_t :=
+| Betree_UpsertFunState_Add : u64 -> betree_UpsertFunState_t
+| Betree_UpsertFunState_Sub : u64 -> betree_UpsertFunState_t
 .
 
 (** [betree_main::betree::Message] *)
-Inductive Betree_message_t :=
-| BetreeMessageInsert : u64 -> Betree_message_t
-| BetreeMessageDelete : Betree_message_t
-| BetreeMessageUpsert : Betree_upsert_fun_state_t -> Betree_message_t
+Inductive betree_Message_t :=
+| Betree_Message_Insert : u64 -> betree_Message_t
+| Betree_Message_Delete : betree_Message_t
+| Betree_Message_Upsert : betree_UpsertFunState_t -> betree_Message_t
 .
 
 (** [betree_main::betree::Leaf] *)
-Record Betree_leaf_t :=
-mkBetree_leaf_t {
-  Betree_leaf_id : u64; Betree_leaf_size : u64;
+Record betree_Leaf_t :=
+mkbetree_Leaf_t {
+  betree_Leaf_id : u64; betree_Leaf_size : u64;
 }
 .
 
 (** [betree_main::betree::Internal] *)
-Inductive Betree_internal_t :=
-| mkBetree_internal_t :
+Inductive betree_Internal_t :=
+| mkbetree_Internal_t :
   u64 ->
   u64 ->
-  Betree_node_t ->
-  Betree_node_t ->
-  Betree_internal_t
+  betree_Node_t ->
+  betree_Node_t ->
+  betree_Internal_t
 
 (** [betree_main::betree::Node] *)
-with Betree_node_t :=
-| BetreeNodeInternal : Betree_internal_t -> Betree_node_t
-| BetreeNodeLeaf : Betree_leaf_t -> Betree_node_t
+with betree_Node_t :=
+| Betree_Node_Internal : betree_Internal_t -> betree_Node_t
+| Betree_Node_Leaf : betree_Leaf_t -> betree_Node_t
 .
 
-Definition Betree_internal_id (x : Betree_internal_t) :=
-  match x with | mkBetree_internal_t x0 _ _ _ => x0 end
+Definition betree_Internal_id (x : betree_Internal_t) :=
+  match x with | mkbetree_Internal_t x0 _ _ _ => x0 end
 .
 
-Notation "x1 .(Betree_internal_id)" := (Betree_internal_id x1) (at level 9).
+Notation "x1 .(betree_Internal_id)" := (betree_Internal_id x1) (at level 9).
 
-Definition Betree_internal_pivot (x : Betree_internal_t) :=
-  match x with | mkBetree_internal_t _ x0 _ _ => x0 end
+Definition betree_Internal_pivot (x : betree_Internal_t) :=
+  match x with | mkbetree_Internal_t _ x0 _ _ => x0 end
 .
 
-Notation "x1 .(Betree_internal_pivot)" := (Betree_internal_pivot x1)
+Notation "x1 .(betree_Internal_pivot)" := (betree_Internal_pivot x1)
   (at level 9)
 .
 
-Definition Betree_internal_left (x : Betree_internal_t) :=
-  match x with | mkBetree_internal_t _ _ x0 _ => x0 end
+Definition betree_Internal_left (x : betree_Internal_t) :=
+  match x with | mkbetree_Internal_t _ _ x0 _ => x0 end
 .
 
-Notation "x1 .(Betree_internal_left)" := (Betree_internal_left x1) (at level 9)
+Notation "x1 .(betree_Internal_left)" := (betree_Internal_left x1) (at level 9)
 .
 
-Definition Betree_internal_right (x : Betree_internal_t) :=
-  match x with | mkBetree_internal_t _ _ _ x0 => x0 end
+Definition betree_Internal_right (x : betree_Internal_t) :=
+  match x with | mkbetree_Internal_t _ _ _ x0 => x0 end
 .
 
-Notation "x1 .(Betree_internal_right)" := (Betree_internal_right x1)
+Notation "x1 .(betree_Internal_right)" := (betree_Internal_right x1)
   (at level 9)
 .
 
 (** [betree_main::betree::Params] *)
-Record Betree_params_t :=
-mkBetree_params_t {
-  Betree_params_min_flush_size : u64; Betree_params_split_size : u64;
+Record betree_Params_t :=
+mkbetree_Params_t {
+  betree_Params_min_flush_size : u64; betree_Params_split_size : u64;
 }
 .
 
 (** [betree_main::betree::NodeIdCounter] *)
-Record Betree_node_id_counter_t :=
-mkBetree_node_id_counter_t {
-  Betree_node_id_counter_next_node_id : u64;
+Record betree_NodeIdCounter_t :=
+mkbetree_NodeIdCounter_t {
+  betree_NodeIdCounter_next_node_id : u64;
 }
 .
 
 (** [betree_main::betree::BeTree] *)
-Record Betree_be_tree_t :=
-mkBetree_be_tree_t {
-  Betree_be_tree_params : Betree_params_t;
-  Betree_be_tree_node_id_cnt : Betree_node_id_counter_t;
-  Betree_be_tree_root : Betree_node_t;
+Record betree_BeTree_t :=
+mkbetree_BeTree_t {
+  betree_BeTree_params : betree_Params_t;
+  betree_BeTree_node_id_cnt : betree_NodeIdCounter_t;
+  betree_BeTree_root : betree_Node_t;
 }
 .
 
diff --git a/tests/coq/betree/Primitives.v b/tests/coq/betree/Primitives.v
index 8d6c9c8d..85e38f01 100644
--- a/tests/coq/betree/Primitives.v
+++ b/tests/coq/betree/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
 
 (*** Misc *)
 
-
 Definition string := Coq.Strings.String.string.
 Definition char := Coq.Strings.Ascii.ascii.
 Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
 
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
 
 (*** Scalars *)
 
@@ -408,12 +410,75 @@ Definition core_i64_max   := i64_max %i64.
 Definition core_i128_max  := i64_max %i128.
 Axiom core_isize_max : isize. (** TODO *)
 
-(*** Range *)
-Record range (T : Type) := mk_range {
-  start: T;
-  end_: T;
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+  core_ops_index_Index_Output : Type;
+  core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+  core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+  core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+  core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+  core_ops_deref_Deref_target : Type;
+  core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+  core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+  core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+  core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
 }.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+  core_ops_range_Range_start : T;
+  core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+  core_ops_deref_Deref_target := Self;
+  core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+  core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+  core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+  core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
 
 (*** Arrays *)
 Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -433,51 +498,50 @@ Qed.
 (* TODO: finish the definitions *)
 Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
 
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
 
 (*** Slice *)
 Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
 
 Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
 
 (*** Subslices *)
 
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
 
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
 
 (*** Vectors *)
 
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
 
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
 
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
 
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
 
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
 Proof.
-  unfold vec_length, usize_min.
+  unfold alloc_vec_Vec_length, usize_min.
   split.
   - lia.
   - apply (proj2_sig v).
 Qed.
 
-Definition vec_len (T: Type) (v: vec T) : usize :=
-  exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+  exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
 
 Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
   : list A :=
@@ -488,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
     | S m => x :: (list_update t m a)
 end end.
 
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
-  l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+  l <- f (alloc_vec_Vec_to_list v) ;
   match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
   | left H => Return (exist _ l (scalar_le_max_valid _ _ H))
   | right _ => Fail_ Failure
   end.
 
 (* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
 
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
-  vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
 
 (* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+  if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
 
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l =>
     if to_Z i <? Z.of_nat (length l)
     then Return (list_update l (usize_to_nat i) x)
     else Fail_ Failure).
 
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
-  end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+  core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+  core_slice_index_SliceIndex_Output : Type;
+  core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+  core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+  (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+  x <- inst.(core_slice_index_SliceIndex_get) i s;
+  match x with
+  | None => Fail_ Failure
+  | Some x => Return x
   end.
 
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
-    if to_Z i <? Z.of_nat (length l)
-    then Return (list_update l (usize_to_nat i) x)
-    else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+  (T : Type) :
+  core_ops_range_Range usize -> const_raw_ptr (slice T) -> result (const_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+     sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::get_unchecked_mut]: forward function *)
+Definition core_slice_index_Range_get_unchecked_mut
+  (T : Type) :
+  core_ops_range_Range usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+    sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::index]: forward function *)
+Axiom core_slice_index_Range_index :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (slice T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := slice T;
+  core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (slice T) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_Index (slice T) Idx) :
+  core_ops_index_Index (array T N) Idx := {|
+  core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+  core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_IndexMut (slice T) Idx) :
+  core_ops_index_IndexMut (array T N) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+  core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+  core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+  forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+  forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+  forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+  forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex usize (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := T;
+  core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+  core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+  alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+    alloc_vec_Vec_update_usize v i x.
 
 End Primitives.
diff --git a/tests/coq/hashmap/Hashmap_Funs.v b/tests/coq/hashmap/Hashmap_Funs.v
index 054880d4..3ca52a9f 100644
--- a/tests/coq/hashmap/Hashmap_Funs.v
+++ b/tests/coq/hashmap/Hashmap_Funs.v
@@ -11,98 +11,101 @@ Import Hashmap_Types.
 Module Hashmap_Funs.
 
 (** [hashmap::hash_key]: forward function *)
-Definition hash_key_fwd (k : usize) : result usize :=
+Definition hash_key (k : usize) : result usize :=
   Return k.
 
 (** [hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function *)
-Fixpoint hash_map_allocate_slots_loop_fwd
-  (T : Type) (n : nat) (slots : vec (List_t T)) (n0 : usize) :
-  result (vec (List_t T))
+Fixpoint hashMap_allocate_slots_loop
+  (T : Type) (n : nat) (slots : alloc_vec_Vec (List_t T)) (n0 : usize) :
+  result (alloc_vec_Vec (List_t T))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n1 =>
     if n0 s> 0%usize
     then (
-      slots0 <- vec_push_back (List_t T) slots ListNil;
+      slots0 <- alloc_vec_Vec_push (List_t T) slots List_Nil;
       n2 <- usize_sub n0 1%usize;
-      hash_map_allocate_slots_loop_fwd T n1 slots0 n2)
+      hashMap_allocate_slots_loop T n1 slots0 n2)
     else Return slots
   end
 .
 
 (** [hashmap::HashMap::{0}::allocate_slots]: forward function *)
-Definition hash_map_allocate_slots_fwd
-  (T : Type) (n : nat) (slots : vec (List_t T)) (n0 : usize) :
-  result (vec (List_t T))
+Definition hashMap_allocate_slots
+  (T : Type) (n : nat) (slots : alloc_vec_Vec (List_t T)) (n0 : usize) :
+  result (alloc_vec_Vec (List_t T))
   :=
-  hash_map_allocate_slots_loop_fwd T n slots n0
+  hashMap_allocate_slots_loop T n slots n0
 .
 
 (** [hashmap::HashMap::{0}::new_with_capacity]: forward function *)
-Definition hash_map_new_with_capacity_fwd
+Definition hashMap_new_with_capacity
   (T : Type) (n : nat) (capacity : usize) (max_load_dividend : usize)
   (max_load_divisor : usize) :
-  result (Hash_map_t T)
+  result (HashMap_t T)
   :=
-  let v := vec_new (List_t T) in
-  slots <- hash_map_allocate_slots_fwd T n v capacity;
+  let v := alloc_vec_Vec_new (List_t T) in
+  slots <- hashMap_allocate_slots T n v capacity;
   i <- usize_mul capacity max_load_dividend;
   i0 <- usize_div i max_load_divisor;
   Return
     {|
-      Hash_map_num_entries := 0%usize;
-      Hash_map_max_load_factor := (max_load_dividend, max_load_divisor);
-      Hash_map_max_load := i0;
-      Hash_map_slots := slots
+      hashMap_num_entries := 0%usize;
+      hashMap_max_load_factor := (max_load_dividend, max_load_divisor);
+      hashMap_max_load := i0;
+      hashMap_slots := slots
     |}
 .
 
 (** [hashmap::HashMap::{0}::new]: forward function *)
-Definition hash_map_new_fwd (T : Type) (n : nat) : result (Hash_map_t T) :=
-  hash_map_new_with_capacity_fwd T n 32%usize 4%usize 5%usize
+Definition hashMap_new (T : Type) (n : nat) : result (HashMap_t T) :=
+  hashMap_new_with_capacity T n 32%usize 4%usize 5%usize
 .
 
 (** [hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint hash_map_clear_loop_fwd_back
-  (T : Type) (n : nat) (slots : vec (List_t T)) (i : usize) :
-  result (vec (List_t T))
+Fixpoint hashMap_clear_loop
+  (T : Type) (n : nat) (slots : alloc_vec_Vec (List_t T)) (i : usize) :
+  result (alloc_vec_Vec (List_t T))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    let i0 := vec_len (List_t T) slots in
+    let i0 := alloc_vec_Vec_len (List_t T) slots in
     if i s< i0
     then (
       i1 <- usize_add i 1%usize;
-      slots0 <- vec_index_mut_back (List_t T) slots i ListNil;
-      hash_map_clear_loop_fwd_back T n0 slots0 i1)
+      slots0 <-
+        alloc_vec_Vec_index_mut_back (List_t T) usize
+          (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+          slots i List_Nil;
+      hashMap_clear_loop T n0 slots0 i1)
     else Return slots
   end
 .
 
 (** [hashmap::HashMap::{0}::clear]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_clear_fwd_back
-  (T : Type) (n : nat) (self : Hash_map_t T) : result (Hash_map_t T) :=
-  v <- hash_map_clear_loop_fwd_back T n self.(Hash_map_slots) 0%usize;
+Definition hashMap_clear
+  (T : Type) (n : nat) (self : HashMap_t T) : result (HashMap_t T) :=
+  v <- hashMap_clear_loop T n self.(hashMap_slots) 0%usize;
   Return
     {|
-      Hash_map_num_entries := 0%usize;
-      Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
-      Hash_map_max_load := self.(Hash_map_max_load);
-      Hash_map_slots := v
+      hashMap_num_entries := 0%usize;
+      hashMap_max_load_factor := self.(hashMap_max_load_factor);
+      hashMap_max_load := self.(hashMap_max_load);
+      hashMap_slots := v
     |}
 .
 
 (** [hashmap::HashMap::{0}::len]: forward function *)
-Definition hash_map_len_fwd (T : Type) (self : Hash_map_t T) : result usize :=
-  Return self.(Hash_map_num_entries)
+Definition hashMap_len (T : Type) (self : HashMap_t T) : result usize :=
+  Return self.(hashMap_num_entries)
 .
 
 (** [hashmap::HashMap::{0}::insert_in_list]: loop 0: forward function *)
-Fixpoint hash_map_insert_in_list_loop_fwd
+Fixpoint hashMap_insert_in_list_loop
   (T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
   result bool
   :=
@@ -110,25 +113,25 @@ Fixpoint hash_map_insert_in_list_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey cvalue tl =>
+    | List_Cons ckey cvalue tl =>
       if ckey s= key
       then Return false
-      else hash_map_insert_in_list_loop_fwd T n0 key value tl
-    | ListNil => Return true
+      else hashMap_insert_in_list_loop T n0 key value tl
+    | List_Nil => Return true
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::insert_in_list]: forward function *)
-Definition hash_map_insert_in_list_fwd
+Definition hashMap_insert_in_list
   (T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
   result bool
   :=
-  hash_map_insert_in_list_loop_fwd T n key value ls
+  hashMap_insert_in_list_loop T n key value ls
 .
 
 (** [hashmap::HashMap::{0}::insert_in_list]: loop 0: backward function 0 *)
-Fixpoint hash_map_insert_in_list_loop_back
+Fixpoint hashMap_insert_in_list_loop_back
   (T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
   result (List_t T)
   :=
@@ -136,255 +139,275 @@ Fixpoint hash_map_insert_in_list_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey cvalue tl =>
+    | List_Cons ckey cvalue tl =>
       if ckey s= key
-      then Return (ListCons ckey value tl)
+      then Return (List_Cons ckey value tl)
       else (
-        tl0 <- hash_map_insert_in_list_loop_back T n0 key value tl;
-        Return (ListCons ckey cvalue tl0))
-    | ListNil => let l := ListNil in Return (ListCons key value l)
+        tl0 <- hashMap_insert_in_list_loop_back T n0 key value tl;
+        Return (List_Cons ckey cvalue tl0))
+    | List_Nil => let l := List_Nil in Return (List_Cons key value l)
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::insert_in_list]: backward function 0 *)
-Definition hash_map_insert_in_list_back
+Definition hashMap_insert_in_list_back
   (T : Type) (n : nat) (key : usize) (value : T) (ls : List_t T) :
   result (List_t T)
   :=
-  hash_map_insert_in_list_loop_back T n key value ls
+  hashMap_insert_in_list_loop_back T n key value ls
 .
 
 (** [hashmap::HashMap::{0}::insert_no_resize]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_insert_no_resize_fwd_back
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) (value : T) :
-  result (Hash_map_t T)
+Definition hashMap_insert_no_resize
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) (value : T) :
+  result (HashMap_t T)
   :=
-  hash <- hash_key_fwd key;
-  let i := vec_len (List_t T) self.(Hash_map_slots) in
+  hash <- hash_key key;
+  let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
-  inserted <- hash_map_insert_in_list_fwd T n key value l;
+  l <-
+    alloc_vec_Vec_index_mut (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod;
+  inserted <- hashMap_insert_in_list T n key value l;
   if inserted
   then (
-    i0 <- usize_add self.(Hash_map_num_entries) 1%usize;
-    l0 <- hash_map_insert_in_list_back T n key value l;
-    v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+    i0 <- usize_add self.(hashMap_num_entries) 1%usize;
+    l0 <- hashMap_insert_in_list_back T n key value l;
+    v <-
+      alloc_vec_Vec_index_mut_back (List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+        self.(hashMap_slots) hash_mod l0;
     Return
       {|
-        Hash_map_num_entries := i0;
-        Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
-        Hash_map_max_load := self.(Hash_map_max_load);
-        Hash_map_slots := v
+        hashMap_num_entries := i0;
+        hashMap_max_load_factor := self.(hashMap_max_load_factor);
+        hashMap_max_load := self.(hashMap_max_load);
+        hashMap_slots := v
       |})
   else (
-    l0 <- hash_map_insert_in_list_back T n key value l;
-    v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+    l0 <- hashMap_insert_in_list_back T n key value l;
+    v <-
+      alloc_vec_Vec_index_mut_back (List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+        self.(hashMap_slots) hash_mod l0;
     Return
       {|
-        Hash_map_num_entries := self.(Hash_map_num_entries);
-        Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
-        Hash_map_max_load := self.(Hash_map_max_load);
-        Hash_map_slots := v
+        hashMap_num_entries := self.(hashMap_num_entries);
+        hashMap_max_load_factor := self.(hashMap_max_load_factor);
+        hashMap_max_load := self.(hashMap_max_load);
+        hashMap_slots := v
       |})
 .
 
 (** [hashmap::HashMap::{0}::move_elements_from_list]: loop 0: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint hash_map_move_elements_from_list_loop_fwd_back
-  (T : Type) (n : nat) (ntable : Hash_map_t T) (ls : List_t T) :
-  result (Hash_map_t T)
+Fixpoint hashMap_move_elements_from_list_loop
+  (T : Type) (n : nat) (ntable : HashMap_t T) (ls : List_t T) :
+  result (HashMap_t T)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons k v tl =>
-      ntable0 <- hash_map_insert_no_resize_fwd_back T n0 ntable k v;
-      hash_map_move_elements_from_list_loop_fwd_back T n0 ntable0 tl
-    | ListNil => Return ntable
+    | List_Cons k v tl =>
+      ntable0 <- hashMap_insert_no_resize T n0 ntable k v;
+      hashMap_move_elements_from_list_loop T n0 ntable0 tl
+    | List_Nil => Return ntable
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::move_elements_from_list]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_move_elements_from_list_fwd_back
-  (T : Type) (n : nat) (ntable : Hash_map_t T) (ls : List_t T) :
-  result (Hash_map_t T)
+Definition hashMap_move_elements_from_list
+  (T : Type) (n : nat) (ntable : HashMap_t T) (ls : List_t T) :
+  result (HashMap_t T)
   :=
-  hash_map_move_elements_from_list_loop_fwd_back T n ntable ls
+  hashMap_move_elements_from_list_loop T n ntable ls
 .
 
 (** [hashmap::HashMap::{0}::move_elements]: loop 0: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint hash_map_move_elements_loop_fwd_back
-  (T : Type) (n : nat) (ntable : Hash_map_t T) (slots : vec (List_t T))
-  (i : usize) :
-  result ((Hash_map_t T) * (vec (List_t T)))
+Fixpoint hashMap_move_elements_loop
+  (T : Type) (n : nat) (ntable : HashMap_t T)
+  (slots : alloc_vec_Vec (List_t T)) (i : usize) :
+  result ((HashMap_t T) * (alloc_vec_Vec (List_t T)))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    let i0 := vec_len (List_t T) slots in
+    let i0 := alloc_vec_Vec_len (List_t T) slots in
     if i s< i0
     then (
-      l <- vec_index_mut_fwd (List_t T) slots i;
-      let ls := mem_replace_fwd (List_t T) l ListNil in
-      ntable0 <- hash_map_move_elements_from_list_fwd_back T n0 ntable ls;
+      l <-
+        alloc_vec_Vec_index_mut (List_t T) usize
+          (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+          slots i;
+      let ls := core_mem_replace (List_t T) l List_Nil in
+      ntable0 <- hashMap_move_elements_from_list T n0 ntable ls;
       i1 <- usize_add i 1%usize;
-      let l0 := mem_replace_back (List_t T) l ListNil in
-      slots0 <- vec_index_mut_back (List_t T) slots i l0;
-      hash_map_move_elements_loop_fwd_back T n0 ntable0 slots0 i1)
+      let l0 := core_mem_replace_back (List_t T) l List_Nil in
+      slots0 <-
+        alloc_vec_Vec_index_mut_back (List_t T) usize
+          (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+          slots i l0;
+      hashMap_move_elements_loop T n0 ntable0 slots0 i1)
     else Return (ntable, slots)
   end
 .
 
 (** [hashmap::HashMap::{0}::move_elements]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_move_elements_fwd_back
-  (T : Type) (n : nat) (ntable : Hash_map_t T) (slots : vec (List_t T))
-  (i : usize) :
-  result ((Hash_map_t T) * (vec (List_t T)))
+Definition hashMap_move_elements
+  (T : Type) (n : nat) (ntable : HashMap_t T)
+  (slots : alloc_vec_Vec (List_t T)) (i : usize) :
+  result ((HashMap_t T) * (alloc_vec_Vec (List_t T)))
   :=
-  hash_map_move_elements_loop_fwd_back T n ntable slots i
+  hashMap_move_elements_loop T n ntable slots i
 .
 
 (** [hashmap::HashMap::{0}::try_resize]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_try_resize_fwd_back
-  (T : Type) (n : nat) (self : Hash_map_t T) : result (Hash_map_t T) :=
+Definition hashMap_try_resize
+  (T : Type) (n : nat) (self : HashMap_t T) : result (HashMap_t T) :=
   max_usize <- scalar_cast U32 Usize core_u32_max;
-  let capacity := vec_len (List_t T) self.(Hash_map_slots) in
+  let capacity := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   n1 <- usize_div max_usize 2%usize;
-  let (i, i0) := self.(Hash_map_max_load_factor) in
+  let (i, i0) := self.(hashMap_max_load_factor) in
   i1 <- usize_div n1 i;
   if capacity s<= i1
   then (
     i2 <- usize_mul capacity 2%usize;
-    ntable <- hash_map_new_with_capacity_fwd T n i2 i i0;
-    p <-
-      hash_map_move_elements_fwd_back T n ntable self.(Hash_map_slots) 0%usize;
+    ntable <- hashMap_new_with_capacity T n i2 i i0;
+    p <- hashMap_move_elements T n ntable self.(hashMap_slots) 0%usize;
     let (ntable0, _) := p in
     Return
       {|
-        Hash_map_num_entries := self.(Hash_map_num_entries);
-        Hash_map_max_load_factor := (i, i0);
-        Hash_map_max_load := ntable0.(Hash_map_max_load);
-        Hash_map_slots := ntable0.(Hash_map_slots)
+        hashMap_num_entries := self.(hashMap_num_entries);
+        hashMap_max_load_factor := (i, i0);
+        hashMap_max_load := ntable0.(hashMap_max_load);
+        hashMap_slots := ntable0.(hashMap_slots)
       |})
   else
     Return
       {|
-        Hash_map_num_entries := self.(Hash_map_num_entries);
-        Hash_map_max_load_factor := (i, i0);
-        Hash_map_max_load := self.(Hash_map_max_load);
-        Hash_map_slots := self.(Hash_map_slots)
+        hashMap_num_entries := self.(hashMap_num_entries);
+        hashMap_max_load_factor := (i, i0);
+        hashMap_max_load := self.(hashMap_max_load);
+        hashMap_slots := self.(hashMap_slots)
       |}
 .
 
 (** [hashmap::HashMap::{0}::insert]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hash_map_insert_fwd_back
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) (value : T) :
-  result (Hash_map_t T)
+Definition hashMap_insert
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) (value : T) :
+  result (HashMap_t T)
   :=
-  self0 <- hash_map_insert_no_resize_fwd_back T n self key value;
-  i <- hash_map_len_fwd T self0;
-  if i s> self0.(Hash_map_max_load)
-  then hash_map_try_resize_fwd_back T n self0
+  self0 <- hashMap_insert_no_resize T n self key value;
+  i <- hashMap_len T self0;
+  if i s> self0.(hashMap_max_load)
+  then hashMap_try_resize T n self0
   else Return self0
 .
 
 (** [hashmap::HashMap::{0}::contains_key_in_list]: loop 0: forward function *)
-Fixpoint hash_map_contains_key_in_list_loop_fwd
+Fixpoint hashMap_contains_key_in_list_loop
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result bool :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey t tl =>
+    | List_Cons ckey t tl =>
       if ckey s= key
       then Return true
-      else hash_map_contains_key_in_list_loop_fwd T n0 key tl
-    | ListNil => Return false
+      else hashMap_contains_key_in_list_loop T n0 key tl
+    | List_Nil => Return false
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::contains_key_in_list]: forward function *)
-Definition hash_map_contains_key_in_list_fwd
+Definition hashMap_contains_key_in_list
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result bool :=
-  hash_map_contains_key_in_list_loop_fwd T n key ls
+  hashMap_contains_key_in_list_loop T n key ls
 .
 
 (** [hashmap::HashMap::{0}::contains_key]: forward function *)
-Definition hash_map_contains_key_fwd
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) : result bool :=
-  hash <- hash_key_fwd key;
-  let i := vec_len (List_t T) self.(Hash_map_slots) in
+Definition hashMap_contains_key
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) : result bool :=
+  hash <- hash_key key;
+  let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_fwd (List_t T) self.(Hash_map_slots) hash_mod;
-  hash_map_contains_key_in_list_fwd T n key l
+  l <-
+    alloc_vec_Vec_index (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod;
+  hashMap_contains_key_in_list T n key l
 .
 
 (** [hashmap::HashMap::{0}::get_in_list]: loop 0: forward function *)
-Fixpoint hash_map_get_in_list_loop_fwd
+Fixpoint hashMap_get_in_list_loop
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey cvalue tl =>
+    | List_Cons ckey cvalue tl =>
       if ckey s= key
       then Return cvalue
-      else hash_map_get_in_list_loop_fwd T n0 key tl
-    | ListNil => Fail_ Failure
+      else hashMap_get_in_list_loop T n0 key tl
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::get_in_list]: forward function *)
-Definition hash_map_get_in_list_fwd
+Definition hashMap_get_in_list
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result T :=
-  hash_map_get_in_list_loop_fwd T n key ls
+  hashMap_get_in_list_loop T n key ls
 .
 
 (** [hashmap::HashMap::{0}::get]: forward function *)
-Definition hash_map_get_fwd
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) : result T :=
-  hash <- hash_key_fwd key;
-  let i := vec_len (List_t T) self.(Hash_map_slots) in
+Definition hashMap_get
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) : result T :=
+  hash <- hash_key key;
+  let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_fwd (List_t T) self.(Hash_map_slots) hash_mod;
-  hash_map_get_in_list_fwd T n key l
+  l <-
+    alloc_vec_Vec_index (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod;
+  hashMap_get_in_list T n key l
 .
 
 (** [hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function *)
-Fixpoint hash_map_get_mut_in_list_loop_fwd
+Fixpoint hashMap_get_mut_in_list_loop
   (T : Type) (n : nat) (ls : List_t T) (key : usize) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey cvalue tl =>
+    | List_Cons ckey cvalue tl =>
       if ckey s= key
       then Return cvalue
-      else hash_map_get_mut_in_list_loop_fwd T n0 tl key
-    | ListNil => Fail_ Failure
+      else hashMap_get_mut_in_list_loop T n0 tl key
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::get_mut_in_list]: forward function *)
-Definition hash_map_get_mut_in_list_fwd
+Definition hashMap_get_mut_in_list
   (T : Type) (n : nat) (ls : List_t T) (key : usize) : result T :=
-  hash_map_get_mut_in_list_loop_fwd T n ls key
+  hashMap_get_mut_in_list_loop T n ls key
 .
 
 (** [hashmap::HashMap::{0}::get_mut_in_list]: loop 0: backward function 0 *)
-Fixpoint hash_map_get_mut_in_list_loop_back
+Fixpoint hashMap_get_mut_in_list_loop_back
   (T : Type) (n : nat) (ls : List_t T) (key : usize) (ret : T) :
   result (List_t T)
   :=
@@ -392,196 +415,219 @@ Fixpoint hash_map_get_mut_in_list_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey cvalue tl =>
+    | List_Cons ckey cvalue tl =>
       if ckey s= key
-      then Return (ListCons ckey ret tl)
+      then Return (List_Cons ckey ret tl)
       else (
-        tl0 <- hash_map_get_mut_in_list_loop_back T n0 tl key ret;
-        Return (ListCons ckey cvalue tl0))
-    | ListNil => Fail_ Failure
+        tl0 <- hashMap_get_mut_in_list_loop_back T n0 tl key ret;
+        Return (List_Cons ckey cvalue tl0))
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::get_mut_in_list]: backward function 0 *)
-Definition hash_map_get_mut_in_list_back
+Definition hashMap_get_mut_in_list_back
   (T : Type) (n : nat) (ls : List_t T) (key : usize) (ret : T) :
   result (List_t T)
   :=
-  hash_map_get_mut_in_list_loop_back T n ls key ret
+  hashMap_get_mut_in_list_loop_back T n ls key ret
 .
 
 (** [hashmap::HashMap::{0}::get_mut]: forward function *)
-Definition hash_map_get_mut_fwd
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) : result T :=
-  hash <- hash_key_fwd key;
-  let i := vec_len (List_t T) self.(Hash_map_slots) in
+Definition hashMap_get_mut
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) : result T :=
+  hash <- hash_key key;
+  let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
-  hash_map_get_mut_in_list_fwd T n l key
+  l <-
+    alloc_vec_Vec_index_mut (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod;
+  hashMap_get_mut_in_list T n l key
 .
 
 (** [hashmap::HashMap::{0}::get_mut]: backward function 0 *)
-Definition hash_map_get_mut_back
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) (ret : T) :
-  result (Hash_map_t T)
+Definition hashMap_get_mut_back
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) (ret : T) :
+  result (HashMap_t T)
   :=
-  hash <- hash_key_fwd key;
-  let i := vec_len (List_t T) self.(Hash_map_slots) in
+  hash <- hash_key key;
+  let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
-  l0 <- hash_map_get_mut_in_list_back T n l key ret;
-  v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+  l <-
+    alloc_vec_Vec_index_mut (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod;
+  l0 <- hashMap_get_mut_in_list_back T n l key ret;
+  v <-
+    alloc_vec_Vec_index_mut_back (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod l0;
   Return
     {|
-      Hash_map_num_entries := self.(Hash_map_num_entries);
-      Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
-      Hash_map_max_load := self.(Hash_map_max_load);
-      Hash_map_slots := v
+      hashMap_num_entries := self.(hashMap_num_entries);
+      hashMap_max_load_factor := self.(hashMap_max_load_factor);
+      hashMap_max_load := self.(hashMap_max_load);
+      hashMap_slots := v
     |}
 .
 
 (** [hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function *)
-Fixpoint hash_map_remove_from_list_loop_fwd
+Fixpoint hashMap_remove_from_list_loop
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result (option T) :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey t tl =>
+    | List_Cons ckey t tl =>
       if ckey s= key
       then
-        let mv_ls := mem_replace_fwd (List_t T) (ListCons ckey t tl) ListNil in
+        let mv_ls := core_mem_replace (List_t T) (List_Cons ckey t tl) List_Nil
+          in
         match mv_ls with
-        | ListCons i cvalue tl0 => Return (Some cvalue)
-        | ListNil => Fail_ Failure
+        | List_Cons i cvalue tl0 => Return (Some cvalue)
+        | List_Nil => Fail_ Failure
         end
-      else hash_map_remove_from_list_loop_fwd T n0 key tl
-    | ListNil => Return None
+      else hashMap_remove_from_list_loop T n0 key tl
+    | List_Nil => Return None
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::remove_from_list]: forward function *)
-Definition hash_map_remove_from_list_fwd
+Definition hashMap_remove_from_list
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result (option T) :=
-  hash_map_remove_from_list_loop_fwd T n key ls
+  hashMap_remove_from_list_loop T n key ls
 .
 
 (** [hashmap::HashMap::{0}::remove_from_list]: loop 0: backward function 1 *)
-Fixpoint hash_map_remove_from_list_loop_back
+Fixpoint hashMap_remove_from_list_loop_back
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result (List_t T) :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons ckey t tl =>
+    | List_Cons ckey t tl =>
       if ckey s= key
       then
-        let mv_ls := mem_replace_fwd (List_t T) (ListCons ckey t tl) ListNil in
+        let mv_ls := core_mem_replace (List_t T) (List_Cons ckey t tl) List_Nil
+          in
         match mv_ls with
-        | ListCons i cvalue tl0 => Return tl0
-        | ListNil => Fail_ Failure
+        | List_Cons i cvalue tl0 => Return tl0
+        | List_Nil => Fail_ Failure
         end
       else (
-        tl0 <- hash_map_remove_from_list_loop_back T n0 key tl;
-        Return (ListCons ckey t tl0))
-    | ListNil => Return ListNil
+        tl0 <- hashMap_remove_from_list_loop_back T n0 key tl;
+        Return (List_Cons ckey t tl0))
+    | List_Nil => Return List_Nil
     end
   end
 .
 
 (** [hashmap::HashMap::{0}::remove_from_list]: backward function 1 *)
-Definition hash_map_remove_from_list_back
+Definition hashMap_remove_from_list_back
   (T : Type) (n : nat) (key : usize) (ls : List_t T) : result (List_t T) :=
-  hash_map_remove_from_list_loop_back T n key ls
+  hashMap_remove_from_list_loop_back T n key ls
 .
 
 (** [hashmap::HashMap::{0}::remove]: forward function *)
-Definition hash_map_remove_fwd
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) :
+Definition hashMap_remove
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) :
   result (option T)
   :=
-  hash <- hash_key_fwd key;
-  let i := vec_len (List_t T) self.(Hash_map_slots) in
+  hash <- hash_key key;
+  let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
-  x <- hash_map_remove_from_list_fwd T n key l;
+  l <-
+    alloc_vec_Vec_index_mut (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod;
+  x <- hashMap_remove_from_list T n key l;
   match x with
   | None => Return None
   | Some x0 =>
-    _ <- usize_sub self.(Hash_map_num_entries) 1%usize; Return (Some x0)
+    _ <- usize_sub self.(hashMap_num_entries) 1%usize; Return (Some x0)
   end
 .
 
 (** [hashmap::HashMap::{0}::remove]: backward function 0 *)
-Definition hash_map_remove_back
-  (T : Type) (n : nat) (self : Hash_map_t T) (key : usize) :
-  result (Hash_map_t T)
+Definition hashMap_remove_back
+  (T : Type) (n : nat) (self : HashMap_t T) (key : usize) :
+  result (HashMap_t T)
   :=
-  hash <- hash_key_fwd key;
-  let i := vec_len (List_t T) self.(Hash_map_slots) in
+  hash <- hash_key key;
+  let i := alloc_vec_Vec_len (List_t T) self.(hashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_mut_fwd (List_t T) self.(Hash_map_slots) hash_mod;
-  x <- hash_map_remove_from_list_fwd T n key l;
+  l <-
+    alloc_vec_Vec_index_mut (List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+      self.(hashMap_slots) hash_mod;
+  x <- hashMap_remove_from_list T n key l;
   match x with
   | None =>
-    l0 <- hash_map_remove_from_list_back T n key l;
-    v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+    l0 <- hashMap_remove_from_list_back T n key l;
+    v <-
+      alloc_vec_Vec_index_mut_back (List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+        self.(hashMap_slots) hash_mod l0;
     Return
       {|
-        Hash_map_num_entries := self.(Hash_map_num_entries);
-        Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
-        Hash_map_max_load := self.(Hash_map_max_load);
-        Hash_map_slots := v
+        hashMap_num_entries := self.(hashMap_num_entries);
+        hashMap_max_load_factor := self.(hashMap_max_load_factor);
+        hashMap_max_load := self.(hashMap_max_load);
+        hashMap_slots := v
       |}
   | Some x0 =>
-    i0 <- usize_sub self.(Hash_map_num_entries) 1%usize;
-    l0 <- hash_map_remove_from_list_back T n key l;
-    v <- vec_index_mut_back (List_t T) self.(Hash_map_slots) hash_mod l0;
+    i0 <- usize_sub self.(hashMap_num_entries) 1%usize;
+    l0 <- hashMap_remove_from_list_back T n key l;
+    v <-
+      alloc_vec_Vec_index_mut_back (List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (List_t T))
+        self.(hashMap_slots) hash_mod l0;
     Return
       {|
-        Hash_map_num_entries := i0;
-        Hash_map_max_load_factor := self.(Hash_map_max_load_factor);
-        Hash_map_max_load := self.(Hash_map_max_load);
-        Hash_map_slots := v
+        hashMap_num_entries := i0;
+        hashMap_max_load_factor := self.(hashMap_max_load_factor);
+        hashMap_max_load := self.(hashMap_max_load);
+        hashMap_slots := v
       |}
   end
 .
 
 (** [hashmap::test1]: forward function *)
-Definition test1_fwd (n : nat) : result unit :=
-  hm <- hash_map_new_fwd u64 n;
-  hm0 <- hash_map_insert_fwd_back u64 n hm 0%usize 42%u64;
-  hm1 <- hash_map_insert_fwd_back u64 n hm0 128%usize 18%u64;
-  hm2 <- hash_map_insert_fwd_back u64 n hm1 1024%usize 138%u64;
-  hm3 <- hash_map_insert_fwd_back u64 n hm2 1056%usize 256%u64;
-  i <- hash_map_get_fwd u64 n hm3 128%usize;
+Definition test1 (n : nat) : result unit :=
+  hm <- hashMap_new u64 n;
+  hm0 <- hashMap_insert u64 n hm 0%usize 42%u64;
+  hm1 <- hashMap_insert u64 n hm0 128%usize 18%u64;
+  hm2 <- hashMap_insert u64 n hm1 1024%usize 138%u64;
+  hm3 <- hashMap_insert u64 n hm2 1056%usize 256%u64;
+  i <- hashMap_get u64 n hm3 128%usize;
   if negb (i s= 18%u64)
   then Fail_ Failure
   else (
-    hm4 <- hash_map_get_mut_back u64 n hm3 1024%usize 56%u64;
-    i0 <- hash_map_get_fwd u64 n hm4 1024%usize;
+    hm4 <- hashMap_get_mut_back u64 n hm3 1024%usize 56%u64;
+    i0 <- hashMap_get u64 n hm4 1024%usize;
     if negb (i0 s= 56%u64)
     then Fail_ Failure
     else (
-      x <- hash_map_remove_fwd u64 n hm4 1024%usize;
+      x <- hashMap_remove u64 n hm4 1024%usize;
       match x with
       | None => Fail_ Failure
       | Some x0 =>
         if negb (x0 s= 56%u64)
         then Fail_ Failure
         else (
-          hm5 <- hash_map_remove_back u64 n hm4 1024%usize;
-          i1 <- hash_map_get_fwd u64 n hm5 0%usize;
+          hm5 <- hashMap_remove_back u64 n hm4 1024%usize;
+          i1 <- hashMap_get u64 n hm5 0%usize;
           if negb (i1 s= 42%u64)
           then Fail_ Failure
           else (
-            i2 <- hash_map_get_fwd u64 n hm5 128%usize;
+            i2 <- hashMap_get u64 n hm5 128%usize;
             if negb (i2 s= 18%u64)
             then Fail_ Failure
             else (
-              i3 <- hash_map_get_fwd u64 n hm5 1056%usize;
+              i3 <- hashMap_get u64 n hm5 1056%usize;
               if negb (i3 s= 256%u64) then Fail_ Failure else Return tt)))
       end))
 .
diff --git a/tests/coq/hashmap/Hashmap_Types.v b/tests/coq/hashmap/Hashmap_Types.v
index dbde6be9..63d30eeb 100644
--- a/tests/coq/hashmap/Hashmap_Types.v
+++ b/tests/coq/hashmap/Hashmap_Types.v
@@ -10,27 +10,27 @@ Module Hashmap_Types.
 
 (** [hashmap::List] *)
 Inductive List_t (T : Type) :=
-| ListCons : usize -> T -> List_t T -> List_t T
-| ListNil : List_t T
+| List_Cons : usize -> T -> List_t T -> List_t T
+| List_Nil : List_t T
 .
 
-Arguments ListCons {T} _ _ _.
-Arguments ListNil {T}.
+Arguments List_Cons {T} _ _ _.
+Arguments List_Nil {T}.
 
 (** [hashmap::HashMap] *)
-Record Hash_map_t (T : Type) :=
-mkHash_map_t {
-  Hash_map_num_entries : usize;
-  Hash_map_max_load_factor : (usize * usize);
-  Hash_map_max_load : usize;
-  Hash_map_slots : vec (List_t T);
+Record HashMap_t (T : Type) :=
+mkHashMap_t {
+  hashMap_num_entries : usize;
+  hashMap_max_load_factor : (usize * usize);
+  hashMap_max_load : usize;
+  hashMap_slots : alloc_vec_Vec (List_t T);
 }
 .
 
-Arguments mkHash_map_t {T} _ _ _ _.
-Arguments Hash_map_num_entries {T}.
-Arguments Hash_map_max_load_factor {T}.
-Arguments Hash_map_max_load {T}.
-Arguments Hash_map_slots {T}.
+Arguments mkHashMap_t {T} _ _ _ _.
+Arguments hashMap_num_entries {T}.
+Arguments hashMap_max_load_factor {T}.
+Arguments hashMap_max_load {T}.
+Arguments hashMap_slots {T}.
 
 End Hashmap_Types .
diff --git a/tests/coq/hashmap/Primitives.v b/tests/coq/hashmap/Primitives.v
index 8d6c9c8d..85e38f01 100644
--- a/tests/coq/hashmap/Primitives.v
+++ b/tests/coq/hashmap/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
 
 (*** Misc *)
 
-
 Definition string := Coq.Strings.String.string.
 Definition char := Coq.Strings.Ascii.ascii.
 Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
 
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
 
 (*** Scalars *)
 
@@ -408,12 +410,75 @@ Definition core_i64_max   := i64_max %i64.
 Definition core_i128_max  := i64_max %i128.
 Axiom core_isize_max : isize. (** TODO *)
 
-(*** Range *)
-Record range (T : Type) := mk_range {
-  start: T;
-  end_: T;
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+  core_ops_index_Index_Output : Type;
+  core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+  core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+  core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+  core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+  core_ops_deref_Deref_target : Type;
+  core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+  core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+  core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+  core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
 }.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+  core_ops_range_Range_start : T;
+  core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+  core_ops_deref_Deref_target := Self;
+  core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+  core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+  core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+  core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
 
 (*** Arrays *)
 Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -433,51 +498,50 @@ Qed.
 (* TODO: finish the definitions *)
 Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
 
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
 
 (*** Slice *)
 Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
 
 Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
 
 (*** Subslices *)
 
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
 
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
 
 (*** Vectors *)
 
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
 
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
 
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
 
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
 
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
 Proof.
-  unfold vec_length, usize_min.
+  unfold alloc_vec_Vec_length, usize_min.
   split.
   - lia.
   - apply (proj2_sig v).
 Qed.
 
-Definition vec_len (T: Type) (v: vec T) : usize :=
-  exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+  exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
 
 Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
   : list A :=
@@ -488,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
     | S m => x :: (list_update t m a)
 end end.
 
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
-  l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+  l <- f (alloc_vec_Vec_to_list v) ;
   match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
   | left H => Return (exist _ l (scalar_le_max_valid _ _ H))
   | right _ => Fail_ Failure
   end.
 
 (* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
 
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
-  vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
 
 (* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+  if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
 
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l =>
     if to_Z i <? Z.of_nat (length l)
     then Return (list_update l (usize_to_nat i) x)
     else Fail_ Failure).
 
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
-  end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+  core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+  core_slice_index_SliceIndex_Output : Type;
+  core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+  core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+  (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+  x <- inst.(core_slice_index_SliceIndex_get) i s;
+  match x with
+  | None => Fail_ Failure
+  | Some x => Return x
   end.
 
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
-    if to_Z i <? Z.of_nat (length l)
-    then Return (list_update l (usize_to_nat i) x)
-    else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+  (T : Type) :
+  core_ops_range_Range usize -> const_raw_ptr (slice T) -> result (const_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+     sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::get_unchecked_mut]: forward function *)
+Definition core_slice_index_Range_get_unchecked_mut
+  (T : Type) :
+  core_ops_range_Range usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+    sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::index]: forward function *)
+Axiom core_slice_index_Range_index :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (slice T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := slice T;
+  core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (slice T) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_Index (slice T) Idx) :
+  core_ops_index_Index (array T N) Idx := {|
+  core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+  core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_IndexMut (slice T) Idx) :
+  core_ops_index_IndexMut (array T N) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+  core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+  core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+  forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+  forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+  forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+  forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex usize (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := T;
+  core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+  core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+  alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+    alloc_vec_Vec_update_usize v i x.
 
 End Primitives.
diff --git a/tests/coq/hashmap_on_disk/HashmapMain_Funs.v b/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
index a85adbf2..eac78186 100644
--- a/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
+++ b/tests/coq/hashmap_on_disk/HashmapMain_Funs.v
@@ -13,652 +13,668 @@ Import HashmapMain_Opaque.
 Module HashmapMain_Funs.
 
 (** [hashmap_main::hashmap::hash_key]: forward function *)
-Definition hashmap_hash_key_fwd (k : usize) : result usize :=
+Definition hashmap_hash_key (k : usize) : result usize :=
   Return k.
 
 (** [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_allocate_slots_loop_fwd
-  (T : Type) (n : nat) (slots : vec (Hashmap_list_t T)) (n0 : usize) :
-  result (vec (Hashmap_list_t T))
+Fixpoint hashmap_HashMap_allocate_slots_loop
+  (T : Type) (n : nat) (slots : alloc_vec_Vec (hashmap_List_t T)) (n0 : usize)
+  :
+  result (alloc_vec_Vec (hashmap_List_t T))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n1 =>
     if n0 s> 0%usize
     then (
-      slots0 <- vec_push_back (Hashmap_list_t T) slots HashmapListNil;
+      slots0 <- alloc_vec_Vec_push (hashmap_List_t T) slots Hashmap_List_Nil;
       n2 <- usize_sub n0 1%usize;
-      hashmap_hash_map_allocate_slots_loop_fwd T n1 slots0 n2)
+      hashmap_HashMap_allocate_slots_loop T n1 slots0 n2)
     else Return slots
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::allocate_slots]: forward function *)
-Definition hashmap_hash_map_allocate_slots_fwd
-  (T : Type) (n : nat) (slots : vec (Hashmap_list_t T)) (n0 : usize) :
-  result (vec (Hashmap_list_t T))
+Definition hashmap_HashMap_allocate_slots
+  (T : Type) (n : nat) (slots : alloc_vec_Vec (hashmap_List_t T)) (n0 : usize)
+  :
+  result (alloc_vec_Vec (hashmap_List_t T))
   :=
-  hashmap_hash_map_allocate_slots_loop_fwd T n slots n0
+  hashmap_HashMap_allocate_slots_loop T n slots n0
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::new_with_capacity]: forward function *)
-Definition hashmap_hash_map_new_with_capacity_fwd
+Definition hashmap_HashMap_new_with_capacity
   (T : Type) (n : nat) (capacity : usize) (max_load_dividend : usize)
   (max_load_divisor : usize) :
-  result (Hashmap_hash_map_t T)
+  result (hashmap_HashMap_t T)
   :=
-  let v := vec_new (Hashmap_list_t T) in
-  slots <- hashmap_hash_map_allocate_slots_fwd T n v capacity;
+  let v := alloc_vec_Vec_new (hashmap_List_t T) in
+  slots <- hashmap_HashMap_allocate_slots T n v capacity;
   i <- usize_mul capacity max_load_dividend;
   i0 <- usize_div i max_load_divisor;
   Return
     {|
-      Hashmap_hash_map_num_entries := 0%usize;
-      Hashmap_hash_map_max_load_factor := (max_load_dividend, max_load_divisor);
-      Hashmap_hash_map_max_load := i0;
-      Hashmap_hash_map_slots := slots
+      hashmap_HashMap_num_entries := 0%usize;
+      hashmap_HashMap_max_load_factor := (max_load_dividend, max_load_divisor);
+      hashmap_HashMap_max_load := i0;
+      hashmap_HashMap_slots := slots
     |}
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::new]: forward function *)
-Definition hashmap_hash_map_new_fwd
-  (T : Type) (n : nat) : result (Hashmap_hash_map_t T) :=
-  hashmap_hash_map_new_with_capacity_fwd T n 32%usize 4%usize 5%usize
+Definition hashmap_HashMap_new
+  (T : Type) (n : nat) : result (hashmap_HashMap_t T) :=
+  hashmap_HashMap_new_with_capacity T n 32%usize 4%usize 5%usize
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::clear]: loop 0: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint hashmap_hash_map_clear_loop_fwd_back
-  (T : Type) (n : nat) (slots : vec (Hashmap_list_t T)) (i : usize) :
-  result (vec (Hashmap_list_t T))
+Fixpoint hashmap_HashMap_clear_loop
+  (T : Type) (n : nat) (slots : alloc_vec_Vec (hashmap_List_t T)) (i : usize) :
+  result (alloc_vec_Vec (hashmap_List_t T))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    let i0 := vec_len (Hashmap_list_t T) slots in
+    let i0 := alloc_vec_Vec_len (hashmap_List_t T) slots in
     if i s< i0
     then (
       i1 <- usize_add i 1%usize;
-      slots0 <- vec_index_mut_back (Hashmap_list_t T) slots i HashmapListNil;
-      hashmap_hash_map_clear_loop_fwd_back T n0 slots0 i1)
+      slots0 <-
+        alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+          (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+          T)) slots i Hashmap_List_Nil;
+      hashmap_HashMap_clear_loop T n0 slots0 i1)
     else Return slots
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::clear]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_clear_fwd_back
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) :
-  result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_clear
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) :
+  result (hashmap_HashMap_t T)
   :=
-  v <-
-    hashmap_hash_map_clear_loop_fwd_back T n self.(Hashmap_hash_map_slots)
-      0%usize;
+  v <- hashmap_HashMap_clear_loop T n self.(hashmap_HashMap_slots) 0%usize;
   Return
     {|
-      Hashmap_hash_map_num_entries := 0%usize;
-      Hashmap_hash_map_max_load_factor :=
-        self.(Hashmap_hash_map_max_load_factor);
-      Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
-      Hashmap_hash_map_slots := v
+      hashmap_HashMap_num_entries := 0%usize;
+      hashmap_HashMap_max_load_factor := self.(hashmap_HashMap_max_load_factor);
+      hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+      hashmap_HashMap_slots := v
     |}
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::len]: forward function *)
-Definition hashmap_hash_map_len_fwd
-  (T : Type) (self : Hashmap_hash_map_t T) : result usize :=
-  Return self.(Hashmap_hash_map_num_entries)
+Definition hashmap_HashMap_len
+  (T : Type) (self : hashmap_HashMap_t T) : result usize :=
+  Return self.(hashmap_HashMap_num_entries)
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_insert_in_list_loop_fwd
-  (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
+Fixpoint hashmap_HashMap_insert_in_list_loop
+  (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
   result bool
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey cvalue tl =>
+    | Hashmap_List_Cons ckey cvalue tl =>
       if ckey s= key
       then Return false
-      else hashmap_hash_map_insert_in_list_loop_fwd T n0 key value tl
-    | HashmapListNil => Return true
+      else hashmap_HashMap_insert_in_list_loop T n0 key value tl
+    | Hashmap_List_Nil => Return true
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: forward function *)
-Definition hashmap_hash_map_insert_in_list_fwd
-  (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
+Definition hashmap_HashMap_insert_in_list
+  (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
   result bool
   :=
-  hashmap_hash_map_insert_in_list_loop_fwd T n key value ls
+  hashmap_HashMap_insert_in_list_loop T n key value ls
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: loop 0: backward function 0 *)
-Fixpoint hashmap_hash_map_insert_in_list_loop_back
-  (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
-  result (Hashmap_list_t T)
+Fixpoint hashmap_HashMap_insert_in_list_loop_back
+  (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
+  result (hashmap_List_t T)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey cvalue tl =>
+    | Hashmap_List_Cons ckey cvalue tl =>
       if ckey s= key
-      then Return (HashmapListCons ckey value tl)
+      then Return (Hashmap_List_Cons ckey value tl)
       else (
-        tl0 <- hashmap_hash_map_insert_in_list_loop_back T n0 key value tl;
-        Return (HashmapListCons ckey cvalue tl0))
-    | HashmapListNil =>
-      let l := HashmapListNil in Return (HashmapListCons key value l)
+        tl0 <- hashmap_HashMap_insert_in_list_loop_back T n0 key value tl;
+        Return (Hashmap_List_Cons ckey cvalue tl0))
+    | Hashmap_List_Nil =>
+      let l := Hashmap_List_Nil in Return (Hashmap_List_Cons key value l)
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::insert_in_list]: backward function 0 *)
-Definition hashmap_hash_map_insert_in_list_back
-  (T : Type) (n : nat) (key : usize) (value : T) (ls : Hashmap_list_t T) :
-  result (Hashmap_list_t T)
+Definition hashmap_HashMap_insert_in_list_back
+  (T : Type) (n : nat) (key : usize) (value : T) (ls : hashmap_List_t T) :
+  result (hashmap_List_t T)
   :=
-  hashmap_hash_map_insert_in_list_loop_back T n key value ls
+  hashmap_HashMap_insert_in_list_loop_back T n key value ls
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::insert_no_resize]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_insert_no_resize_fwd_back
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) (value : T)
-  :
-  result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_insert_no_resize
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) (value : T) :
+  result (hashmap_HashMap_t T)
   :=
-  hash <- hashmap_hash_key_fwd key;
-  let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+  hash <- hashmap_hash_key key;
+  let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   hash_mod <- usize_rem hash i;
   l <-
-    vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
-  inserted <- hashmap_hash_map_insert_in_list_fwd T n key value l;
+    alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod;
+  inserted <- hashmap_HashMap_insert_in_list T n key value l;
   if inserted
   then (
-    i0 <- usize_add self.(Hashmap_hash_map_num_entries) 1%usize;
-    l0 <- hashmap_hash_map_insert_in_list_back T n key value l;
+    i0 <- usize_add self.(hashmap_HashMap_num_entries) 1%usize;
+    l0 <- hashmap_HashMap_insert_in_list_back T n key value l;
     v <-
-      vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
-        hash_mod l0;
+      alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+        T)) self.(hashmap_HashMap_slots) hash_mod l0;
     Return
       {|
-        Hashmap_hash_map_num_entries := i0;
-        Hashmap_hash_map_max_load_factor :=
-          self.(Hashmap_hash_map_max_load_factor);
-        Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
-        Hashmap_hash_map_slots := v
+        hashmap_HashMap_num_entries := i0;
+        hashmap_HashMap_max_load_factor :=
+          self.(hashmap_HashMap_max_load_factor);
+        hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+        hashmap_HashMap_slots := v
       |})
   else (
-    l0 <- hashmap_hash_map_insert_in_list_back T n key value l;
+    l0 <- hashmap_HashMap_insert_in_list_back T n key value l;
     v <-
-      vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
-        hash_mod l0;
+      alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+        T)) self.(hashmap_HashMap_slots) hash_mod l0;
     Return
       {|
-        Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
-        Hashmap_hash_map_max_load_factor :=
-          self.(Hashmap_hash_map_max_load_factor);
-        Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
-        Hashmap_hash_map_slots := v
+        hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+        hashmap_HashMap_max_load_factor :=
+          self.(hashmap_HashMap_max_load_factor);
+        hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+        hashmap_HashMap_slots := v
       |})
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list]: loop 0: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint hashmap_hash_map_move_elements_from_list_loop_fwd_back
-  (T : Type) (n : nat) (ntable : Hashmap_hash_map_t T) (ls : Hashmap_list_t T)
-  :
-  result (Hashmap_hash_map_t T)
+Fixpoint hashmap_HashMap_move_elements_from_list_loop
+  (T : Type) (n : nat) (ntable : hashmap_HashMap_t T) (ls : hashmap_List_t T) :
+  result (hashmap_HashMap_t T)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons k v tl =>
-      ntable0 <- hashmap_hash_map_insert_no_resize_fwd_back T n0 ntable k v;
-      hashmap_hash_map_move_elements_from_list_loop_fwd_back T n0 ntable0 tl
-    | HashmapListNil => Return ntable
+    | Hashmap_List_Cons k v tl =>
+      ntable0 <- hashmap_HashMap_insert_no_resize T n0 ntable k v;
+      hashmap_HashMap_move_elements_from_list_loop T n0 ntable0 tl
+    | Hashmap_List_Nil => Return ntable
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::move_elements_from_list]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_move_elements_from_list_fwd_back
-  (T : Type) (n : nat) (ntable : Hashmap_hash_map_t T) (ls : Hashmap_list_t T)
-  :
-  result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_move_elements_from_list
+  (T : Type) (n : nat) (ntable : hashmap_HashMap_t T) (ls : hashmap_List_t T) :
+  result (hashmap_HashMap_t T)
   :=
-  hashmap_hash_map_move_elements_from_list_loop_fwd_back T n ntable ls
+  hashmap_HashMap_move_elements_from_list_loop T n ntable ls
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::move_elements]: loop 0: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint hashmap_hash_map_move_elements_loop_fwd_back
-  (T : Type) (n : nat) (ntable : Hashmap_hash_map_t T)
-  (slots : vec (Hashmap_list_t T)) (i : usize) :
-  result ((Hashmap_hash_map_t T) * (vec (Hashmap_list_t T)))
+Fixpoint hashmap_HashMap_move_elements_loop
+  (T : Type) (n : nat) (ntable : hashmap_HashMap_t T)
+  (slots : alloc_vec_Vec (hashmap_List_t T)) (i : usize) :
+  result ((hashmap_HashMap_t T) * (alloc_vec_Vec (hashmap_List_t T)))
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    let i0 := vec_len (Hashmap_list_t T) slots in
+    let i0 := alloc_vec_Vec_len (hashmap_List_t T) slots in
     if i s< i0
     then (
-      l <- vec_index_mut_fwd (Hashmap_list_t T) slots i;
-      let ls := mem_replace_fwd (Hashmap_list_t T) l HashmapListNil in
-      ntable0 <-
-        hashmap_hash_map_move_elements_from_list_fwd_back T n0 ntable ls;
+      l <-
+        alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+          (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+          T)) slots i;
+      let ls := core_mem_replace (hashmap_List_t T) l Hashmap_List_Nil in
+      ntable0 <- hashmap_HashMap_move_elements_from_list T n0 ntable ls;
       i1 <- usize_add i 1%usize;
-      let l0 := mem_replace_back (Hashmap_list_t T) l HashmapListNil in
-      slots0 <- vec_index_mut_back (Hashmap_list_t T) slots i l0;
-      hashmap_hash_map_move_elements_loop_fwd_back T n0 ntable0 slots0 i1)
+      let l0 := core_mem_replace_back (hashmap_List_t T) l Hashmap_List_Nil in
+      slots0 <-
+        alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+          (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+          T)) slots i l0;
+      hashmap_HashMap_move_elements_loop T n0 ntable0 slots0 i1)
     else Return (ntable, slots)
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::move_elements]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_move_elements_fwd_back
-  (T : Type) (n : nat) (ntable : Hashmap_hash_map_t T)
-  (slots : vec (Hashmap_list_t T)) (i : usize) :
-  result ((Hashmap_hash_map_t T) * (vec (Hashmap_list_t T)))
+Definition hashmap_HashMap_move_elements
+  (T : Type) (n : nat) (ntable : hashmap_HashMap_t T)
+  (slots : alloc_vec_Vec (hashmap_List_t T)) (i : usize) :
+  result ((hashmap_HashMap_t T) * (alloc_vec_Vec (hashmap_List_t T)))
   :=
-  hashmap_hash_map_move_elements_loop_fwd_back T n ntable slots i
+  hashmap_HashMap_move_elements_loop T n ntable slots i
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::try_resize]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_try_resize_fwd_back
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) :
-  result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_try_resize
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) :
+  result (hashmap_HashMap_t T)
   :=
   max_usize <- scalar_cast U32 Usize core_u32_max;
-  let capacity := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+  let capacity :=
+    alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   n1 <- usize_div max_usize 2%usize;
-  let (i, i0) := self.(Hashmap_hash_map_max_load_factor) in
+  let (i, i0) := self.(hashmap_HashMap_max_load_factor) in
   i1 <- usize_div n1 i;
   if capacity s<= i1
   then (
     i2 <- usize_mul capacity 2%usize;
-    ntable <- hashmap_hash_map_new_with_capacity_fwd T n i2 i i0;
+    ntable <- hashmap_HashMap_new_with_capacity T n i2 i i0;
     p <-
-      hashmap_hash_map_move_elements_fwd_back T n ntable
-        self.(Hashmap_hash_map_slots) 0%usize;
+      hashmap_HashMap_move_elements T n ntable self.(hashmap_HashMap_slots)
+        0%usize;
     let (ntable0, _) := p in
     Return
       {|
-        Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
-        Hashmap_hash_map_max_load_factor := (i, i0);
-        Hashmap_hash_map_max_load := ntable0.(Hashmap_hash_map_max_load);
-        Hashmap_hash_map_slots := ntable0.(Hashmap_hash_map_slots)
+        hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+        hashmap_HashMap_max_load_factor := (i, i0);
+        hashmap_HashMap_max_load := ntable0.(hashmap_HashMap_max_load);
+        hashmap_HashMap_slots := ntable0.(hashmap_HashMap_slots)
       |})
   else
     Return
       {|
-        Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
-        Hashmap_hash_map_max_load_factor := (i, i0);
-        Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
-        Hashmap_hash_map_slots := self.(Hashmap_hash_map_slots)
+        hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+        hashmap_HashMap_max_load_factor := (i, i0);
+        hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+        hashmap_HashMap_slots := self.(hashmap_HashMap_slots)
       |}
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::insert]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition hashmap_hash_map_insert_fwd_back
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) (value : T)
-  :
-  result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_insert
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) (value : T) :
+  result (hashmap_HashMap_t T)
   :=
-  self0 <- hashmap_hash_map_insert_no_resize_fwd_back T n self key value;
-  i <- hashmap_hash_map_len_fwd T self0;
-  if i s> self0.(Hashmap_hash_map_max_load)
-  then hashmap_hash_map_try_resize_fwd_back T n self0
+  self0 <- hashmap_HashMap_insert_no_resize T n self key value;
+  i <- hashmap_HashMap_len T self0;
+  if i s> self0.(hashmap_HashMap_max_load)
+  then hashmap_HashMap_try_resize T n self0
   else Return self0
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_contains_key_in_list_loop_fwd
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result bool :=
+Fixpoint hashmap_HashMap_contains_key_in_list_loop
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result bool :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey t tl =>
+    | Hashmap_List_Cons ckey t tl =>
       if ckey s= key
       then Return true
-      else hashmap_hash_map_contains_key_in_list_loop_fwd T n0 key tl
-    | HashmapListNil => Return false
+      else hashmap_HashMap_contains_key_in_list_loop T n0 key tl
+    | Hashmap_List_Nil => Return false
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::contains_key_in_list]: forward function *)
-Definition hashmap_hash_map_contains_key_in_list_fwd
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result bool :=
-  hashmap_hash_map_contains_key_in_list_loop_fwd T n key ls
+Definition hashmap_HashMap_contains_key_in_list
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result bool :=
+  hashmap_HashMap_contains_key_in_list_loop T n key ls
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::contains_key]: forward function *)
-Definition hashmap_hash_map_contains_key_fwd
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
+Definition hashmap_HashMap_contains_key
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) :
   result bool
   :=
-  hash <- hashmap_hash_key_fwd key;
-  let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+  hash <- hashmap_hash_key key;
+  let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
-  hashmap_hash_map_contains_key_in_list_fwd T n key l
+  l <-
+    alloc_vec_Vec_index (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod;
+  hashmap_HashMap_contains_key_in_list T n key l
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_get_in_list_loop_fwd
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result T :=
+Fixpoint hashmap_HashMap_get_in_list_loop
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey cvalue tl =>
+    | Hashmap_List_Cons ckey cvalue tl =>
       if ckey s= key
       then Return cvalue
-      else hashmap_hash_map_get_in_list_loop_fwd T n0 key tl
-    | HashmapListNil => Fail_ Failure
+      else hashmap_HashMap_get_in_list_loop T n0 key tl
+    | Hashmap_List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_in_list]: forward function *)
-Definition hashmap_hash_map_get_in_list_fwd
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) : result T :=
-  hashmap_hash_map_get_in_list_loop_fwd T n key ls
+Definition hashmap_HashMap_get_in_list
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) : result T :=
+  hashmap_HashMap_get_in_list_loop T n key ls
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get]: forward function *)
-Definition hashmap_hash_map_get_fwd
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
-  result T
-  :=
-  hash <- hashmap_hash_key_fwd key;
-  let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+Definition hashmap_HashMap_get
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) : result T :=
+  hash <- hashmap_hash_key key;
+  let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   hash_mod <- usize_rem hash i;
-  l <- vec_index_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
-  hashmap_hash_map_get_in_list_fwd T n key l
+  l <-
+    alloc_vec_Vec_index (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod;
+  hashmap_HashMap_get_in_list T n key l
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_get_mut_in_list_loop_fwd
-  (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) : result T :=
+Fixpoint hashmap_HashMap_get_mut_in_list_loop
+  (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey cvalue tl =>
+    | Hashmap_List_Cons ckey cvalue tl =>
       if ckey s= key
       then Return cvalue
-      else hashmap_hash_map_get_mut_in_list_loop_fwd T n0 tl key
-    | HashmapListNil => Fail_ Failure
+      else hashmap_HashMap_get_mut_in_list_loop T n0 tl key
+    | Hashmap_List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: forward function *)
-Definition hashmap_hash_map_get_mut_in_list_fwd
-  (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) : result T :=
-  hashmap_hash_map_get_mut_in_list_loop_fwd T n ls key
+Definition hashmap_HashMap_get_mut_in_list
+  (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) : result T :=
+  hashmap_HashMap_get_mut_in_list_loop T n ls key
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: loop 0: backward function 0 *)
-Fixpoint hashmap_hash_map_get_mut_in_list_loop_back
-  (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) (ret : T) :
-  result (Hashmap_list_t T)
+Fixpoint hashmap_HashMap_get_mut_in_list_loop_back
+  (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) (ret : T) :
+  result (hashmap_List_t T)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey cvalue tl =>
+    | Hashmap_List_Cons ckey cvalue tl =>
       if ckey s= key
-      then Return (HashmapListCons ckey ret tl)
+      then Return (Hashmap_List_Cons ckey ret tl)
       else (
-        tl0 <- hashmap_hash_map_get_mut_in_list_loop_back T n0 tl key ret;
-        Return (HashmapListCons ckey cvalue tl0))
-    | HashmapListNil => Fail_ Failure
+        tl0 <- hashmap_HashMap_get_mut_in_list_loop_back T n0 tl key ret;
+        Return (Hashmap_List_Cons ckey cvalue tl0))
+    | Hashmap_List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_mut_in_list]: backward function 0 *)
-Definition hashmap_hash_map_get_mut_in_list_back
-  (T : Type) (n : nat) (ls : Hashmap_list_t T) (key : usize) (ret : T) :
-  result (Hashmap_list_t T)
+Definition hashmap_HashMap_get_mut_in_list_back
+  (T : Type) (n : nat) (ls : hashmap_List_t T) (key : usize) (ret : T) :
+  result (hashmap_List_t T)
   :=
-  hashmap_hash_map_get_mut_in_list_loop_back T n ls key ret
+  hashmap_HashMap_get_mut_in_list_loop_back T n ls key ret
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_mut]: forward function *)
-Definition hashmap_hash_map_get_mut_fwd
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
-  result T
-  :=
-  hash <- hashmap_hash_key_fwd key;
-  let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+Definition hashmap_HashMap_get_mut
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) : result T :=
+  hash <- hashmap_hash_key key;
+  let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   hash_mod <- usize_rem hash i;
   l <-
-    vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
-  hashmap_hash_map_get_mut_in_list_fwd T n l key
+    alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod;
+  hashmap_HashMap_get_mut_in_list T n l key
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::get_mut]: backward function 0 *)
-Definition hashmap_hash_map_get_mut_back
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) (ret : T) :
-  result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_get_mut_back
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) (ret : T) :
+  result (hashmap_HashMap_t T)
   :=
-  hash <- hashmap_hash_key_fwd key;
-  let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+  hash <- hashmap_hash_key key;
+  let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   hash_mod <- usize_rem hash i;
   l <-
-    vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
-  l0 <- hashmap_hash_map_get_mut_in_list_back T n l key ret;
+    alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod;
+  l0 <- hashmap_HashMap_get_mut_in_list_back T n l key ret;
   v <-
-    vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
-      hash_mod l0;
+    alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod l0;
   Return
     {|
-      Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
-      Hashmap_hash_map_max_load_factor :=
-        self.(Hashmap_hash_map_max_load_factor);
-      Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
-      Hashmap_hash_map_slots := v
+      hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+      hashmap_HashMap_max_load_factor := self.(hashmap_HashMap_max_load_factor);
+      hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+      hashmap_HashMap_slots := v
     |}
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: loop 0: forward function *)
-Fixpoint hashmap_hash_map_remove_from_list_loop_fwd
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
+Fixpoint hashmap_HashMap_remove_from_list_loop
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
   result (option T)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey t tl =>
+    | Hashmap_List_Cons ckey t tl =>
       if ckey s= key
       then
         let mv_ls :=
-          mem_replace_fwd (Hashmap_list_t T) (HashmapListCons ckey t tl)
-            HashmapListNil in
+          core_mem_replace (hashmap_List_t T) (Hashmap_List_Cons ckey t tl)
+            Hashmap_List_Nil in
         match mv_ls with
-        | HashmapListCons i cvalue tl0 => Return (Some cvalue)
-        | HashmapListNil => Fail_ Failure
+        | Hashmap_List_Cons i cvalue tl0 => Return (Some cvalue)
+        | Hashmap_List_Nil => Fail_ Failure
         end
-      else hashmap_hash_map_remove_from_list_loop_fwd T n0 key tl
-    | HashmapListNil => Return None
+      else hashmap_HashMap_remove_from_list_loop T n0 key tl
+    | Hashmap_List_Nil => Return None
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: forward function *)
-Definition hashmap_hash_map_remove_from_list_fwd
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
+Definition hashmap_HashMap_remove_from_list
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
   result (option T)
   :=
-  hashmap_hash_map_remove_from_list_loop_fwd T n key ls
+  hashmap_HashMap_remove_from_list_loop T n key ls
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: loop 0: backward function 1 *)
-Fixpoint hashmap_hash_map_remove_from_list_loop_back
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
-  result (Hashmap_list_t T)
+Fixpoint hashmap_HashMap_remove_from_list_loop_back
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
+  result (hashmap_List_t T)
   :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | HashmapListCons ckey t tl =>
+    | Hashmap_List_Cons ckey t tl =>
       if ckey s= key
       then
         let mv_ls :=
-          mem_replace_fwd (Hashmap_list_t T) (HashmapListCons ckey t tl)
-            HashmapListNil in
+          core_mem_replace (hashmap_List_t T) (Hashmap_List_Cons ckey t tl)
+            Hashmap_List_Nil in
         match mv_ls with
-        | HashmapListCons i cvalue tl0 => Return tl0
-        | HashmapListNil => Fail_ Failure
+        | Hashmap_List_Cons i cvalue tl0 => Return tl0
+        | Hashmap_List_Nil => Fail_ Failure
         end
       else (
-        tl0 <- hashmap_hash_map_remove_from_list_loop_back T n0 key tl;
-        Return (HashmapListCons ckey t tl0))
-    | HashmapListNil => Return HashmapListNil
+        tl0 <- hashmap_HashMap_remove_from_list_loop_back T n0 key tl;
+        Return (Hashmap_List_Cons ckey t tl0))
+    | Hashmap_List_Nil => Return Hashmap_List_Nil
     end
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::remove_from_list]: backward function 1 *)
-Definition hashmap_hash_map_remove_from_list_back
-  (T : Type) (n : nat) (key : usize) (ls : Hashmap_list_t T) :
-  result (Hashmap_list_t T)
+Definition hashmap_HashMap_remove_from_list_back
+  (T : Type) (n : nat) (key : usize) (ls : hashmap_List_t T) :
+  result (hashmap_List_t T)
   :=
-  hashmap_hash_map_remove_from_list_loop_back T n key ls
+  hashmap_HashMap_remove_from_list_loop_back T n key ls
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::remove]: forward function *)
-Definition hashmap_hash_map_remove_fwd
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
+Definition hashmap_HashMap_remove
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) :
   result (option T)
   :=
-  hash <- hashmap_hash_key_fwd key;
-  let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+  hash <- hashmap_hash_key key;
+  let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   hash_mod <- usize_rem hash i;
   l <-
-    vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
-  x <- hashmap_hash_map_remove_from_list_fwd T n key l;
+    alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod;
+  x <- hashmap_HashMap_remove_from_list T n key l;
   match x with
   | None => Return None
   | Some x0 =>
-    _ <- usize_sub self.(Hashmap_hash_map_num_entries) 1%usize;
-    Return (Some x0)
+    _ <- usize_sub self.(hashmap_HashMap_num_entries) 1%usize; Return (Some x0)
   end
 .
 
 (** [hashmap_main::hashmap::HashMap::{0}::remove]: backward function 0 *)
-Definition hashmap_hash_map_remove_back
-  (T : Type) (n : nat) (self : Hashmap_hash_map_t T) (key : usize) :
-  result (Hashmap_hash_map_t T)
+Definition hashmap_HashMap_remove_back
+  (T : Type) (n : nat) (self : hashmap_HashMap_t T) (key : usize) :
+  result (hashmap_HashMap_t T)
   :=
-  hash <- hashmap_hash_key_fwd key;
-  let i := vec_len (Hashmap_list_t T) self.(Hashmap_hash_map_slots) in
+  hash <- hashmap_hash_key key;
+  let i := alloc_vec_Vec_len (hashmap_List_t T) self.(hashmap_HashMap_slots) in
   hash_mod <- usize_rem hash i;
   l <-
-    vec_index_mut_fwd (Hashmap_list_t T) self.(Hashmap_hash_map_slots) hash_mod;
-  x <- hashmap_hash_map_remove_from_list_fwd T n key l;
+    alloc_vec_Vec_index_mut (hashmap_List_t T) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t T))
+      self.(hashmap_HashMap_slots) hash_mod;
+  x <- hashmap_HashMap_remove_from_list T n key l;
   match x with
   | None =>
-    l0 <- hashmap_hash_map_remove_from_list_back T n key l;
+    l0 <- hashmap_HashMap_remove_from_list_back T n key l;
     v <-
-      vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
-        hash_mod l0;
+      alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+        T)) self.(hashmap_HashMap_slots) hash_mod l0;
     Return
       {|
-        Hashmap_hash_map_num_entries := self.(Hashmap_hash_map_num_entries);
-        Hashmap_hash_map_max_load_factor :=
-          self.(Hashmap_hash_map_max_load_factor);
-        Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
-        Hashmap_hash_map_slots := v
+        hashmap_HashMap_num_entries := self.(hashmap_HashMap_num_entries);
+        hashmap_HashMap_max_load_factor :=
+          self.(hashmap_HashMap_max_load_factor);
+        hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+        hashmap_HashMap_slots := v
       |}
   | Some x0 =>
-    i0 <- usize_sub self.(Hashmap_hash_map_num_entries) 1%usize;
-    l0 <- hashmap_hash_map_remove_from_list_back T n key l;
+    i0 <- usize_sub self.(hashmap_HashMap_num_entries) 1%usize;
+    l0 <- hashmap_HashMap_remove_from_list_back T n key l;
     v <-
-      vec_index_mut_back (Hashmap_list_t T) self.(Hashmap_hash_map_slots)
-        hash_mod l0;
+      alloc_vec_Vec_index_mut_back (hashmap_List_t T) usize
+        (core_slice_index_usize_coresliceindexSliceIndexInst (hashmap_List_t
+        T)) self.(hashmap_HashMap_slots) hash_mod l0;
     Return
       {|
-        Hashmap_hash_map_num_entries := i0;
-        Hashmap_hash_map_max_load_factor :=
-          self.(Hashmap_hash_map_max_load_factor);
-        Hashmap_hash_map_max_load := self.(Hashmap_hash_map_max_load);
-        Hashmap_hash_map_slots := v
+        hashmap_HashMap_num_entries := i0;
+        hashmap_HashMap_max_load_factor :=
+          self.(hashmap_HashMap_max_load_factor);
+        hashmap_HashMap_max_load := self.(hashmap_HashMap_max_load);
+        hashmap_HashMap_slots := v
       |}
   end
 .
 
 (** [hashmap_main::hashmap::test1]: forward function *)
-Definition hashmap_test1_fwd (n : nat) : result unit :=
-  hm <- hashmap_hash_map_new_fwd u64 n;
-  hm0 <- hashmap_hash_map_insert_fwd_back u64 n hm 0%usize 42%u64;
-  hm1 <- hashmap_hash_map_insert_fwd_back u64 n hm0 128%usize 18%u64;
-  hm2 <- hashmap_hash_map_insert_fwd_back u64 n hm1 1024%usize 138%u64;
-  hm3 <- hashmap_hash_map_insert_fwd_back u64 n hm2 1056%usize 256%u64;
-  i <- hashmap_hash_map_get_fwd u64 n hm3 128%usize;
+Definition hashmap_test1 (n : nat) : result unit :=
+  hm <- hashmap_HashMap_new u64 n;
+  hm0 <- hashmap_HashMap_insert u64 n hm 0%usize 42%u64;
+  hm1 <- hashmap_HashMap_insert u64 n hm0 128%usize 18%u64;
+  hm2 <- hashmap_HashMap_insert u64 n hm1 1024%usize 138%u64;
+  hm3 <- hashmap_HashMap_insert u64 n hm2 1056%usize 256%u64;
+  i <- hashmap_HashMap_get u64 n hm3 128%usize;
   if negb (i s= 18%u64)
   then Fail_ Failure
   else (
-    hm4 <- hashmap_hash_map_get_mut_back u64 n hm3 1024%usize 56%u64;
-    i0 <- hashmap_hash_map_get_fwd u64 n hm4 1024%usize;
+    hm4 <- hashmap_HashMap_get_mut_back u64 n hm3 1024%usize 56%u64;
+    i0 <- hashmap_HashMap_get u64 n hm4 1024%usize;
     if negb (i0 s= 56%u64)
     then Fail_ Failure
     else (
-      x <- hashmap_hash_map_remove_fwd u64 n hm4 1024%usize;
+      x <- hashmap_HashMap_remove u64 n hm4 1024%usize;
       match x with
       | None => Fail_ Failure
       | Some x0 =>
         if negb (x0 s= 56%u64)
         then Fail_ Failure
         else (
-          hm5 <- hashmap_hash_map_remove_back u64 n hm4 1024%usize;
-          i1 <- hashmap_hash_map_get_fwd u64 n hm5 0%usize;
+          hm5 <- hashmap_HashMap_remove_back u64 n hm4 1024%usize;
+          i1 <- hashmap_HashMap_get u64 n hm5 0%usize;
           if negb (i1 s= 42%u64)
           then Fail_ Failure
           else (
-            i2 <- hashmap_hash_map_get_fwd u64 n hm5 128%usize;
+            i2 <- hashmap_HashMap_get u64 n hm5 128%usize;
             if negb (i2 s= 18%u64)
             then Fail_ Failure
             else (
-              i3 <- hashmap_hash_map_get_fwd u64 n hm5 1056%usize;
+              i3 <- hashmap_HashMap_get u64 n hm5 1056%usize;
               if negb (i3 s= 256%u64) then Fail_ Failure else Return tt)))
       end))
 .
 
 (** [hashmap_main::insert_on_disk]: forward function *)
-Definition insert_on_disk_fwd
+Definition insert_on_disk
   (n : nat) (key : usize) (value : u64) (st : state) : result (state * unit) :=
-  p <- hashmap_utils_deserialize_fwd st;
+  p <- hashmap_utils_deserialize st;
   let (st0, hm) := p in
-  hm0 <- hashmap_hash_map_insert_fwd_back u64 n hm key value;
-  p0 <- hashmap_utils_serialize_fwd hm0 st0;
+  hm0 <- hashmap_HashMap_insert u64 n hm key value;
+  p0 <- hashmap_utils_serialize hm0 st0;
   let (st1, _) := p0 in
   Return (st1, tt)
 .
 
 (** [hashmap_main::main]: forward function *)
-Definition main_fwd : result unit :=
+Definition main : result unit :=
   Return tt.
 
-(** Unit test for [hashmap_main::main] *)
-Check (main_fwd )%return.
-
 End HashmapMain_Funs .
diff --git a/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v b/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v
index 2d17cc29..5e376239 100644
--- a/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v
+++ b/tests/coq/hashmap_on_disk/HashmapMain_Opaque.v
@@ -11,13 +11,13 @@ Import HashmapMain_Types.
 Module HashmapMain_Opaque.
 
 (** [hashmap_main::hashmap_utils::deserialize]: forward function *)
-Axiom hashmap_utils_deserialize_fwd
-  : state -> result (state * (Hashmap_hash_map_t u64))
+Axiom hashmap_utils_deserialize
+  : state -> result (state * (hashmap_HashMap_t u64))
 .
 
 (** [hashmap_main::hashmap_utils::serialize]: forward function *)
-Axiom hashmap_utils_serialize_fwd
-  : Hashmap_hash_map_t u64 -> state -> result (state * unit)
+Axiom hashmap_utils_serialize
+  : hashmap_HashMap_t u64 -> state -> result (state * unit)
 .
 
 End HashmapMain_Opaque .
diff --git a/tests/coq/hashmap_on_disk/HashmapMain_Types.v b/tests/coq/hashmap_on_disk/HashmapMain_Types.v
index 36aaaf25..466119f8 100644
--- a/tests/coq/hashmap_on_disk/HashmapMain_Types.v
+++ b/tests/coq/hashmap_on_disk/HashmapMain_Types.v
@@ -9,29 +9,29 @@ Local Open Scope Primitives_scope.
 Module HashmapMain_Types.
 
 (** [hashmap_main::hashmap::List] *)
-Inductive Hashmap_list_t (T : Type) :=
-| HashmapListCons : usize -> T -> Hashmap_list_t T -> Hashmap_list_t T
-| HashmapListNil : Hashmap_list_t T
+Inductive hashmap_List_t (T : Type) :=
+| Hashmap_List_Cons : usize -> T -> hashmap_List_t T -> hashmap_List_t T
+| Hashmap_List_Nil : hashmap_List_t T
 .
 
-Arguments HashmapListCons {T} _ _ _.
-Arguments HashmapListNil {T}.
+Arguments Hashmap_List_Cons {T} _ _ _.
+Arguments Hashmap_List_Nil {T}.
 
 (** [hashmap_main::hashmap::HashMap] *)
-Record Hashmap_hash_map_t (T : Type) :=
-mkHashmap_hash_map_t {
-  Hashmap_hash_map_num_entries : usize;
-  Hashmap_hash_map_max_load_factor : (usize * usize);
-  Hashmap_hash_map_max_load : usize;
-  Hashmap_hash_map_slots : vec (Hashmap_list_t T);
+Record hashmap_HashMap_t (T : Type) :=
+mkhashmap_HashMap_t {
+  hashmap_HashMap_num_entries : usize;
+  hashmap_HashMap_max_load_factor : (usize * usize);
+  hashmap_HashMap_max_load : usize;
+  hashmap_HashMap_slots : alloc_vec_Vec (hashmap_List_t T);
 }
 .
 
-Arguments mkHashmap_hash_map_t {T} _ _ _ _.
-Arguments Hashmap_hash_map_num_entries {T}.
-Arguments Hashmap_hash_map_max_load_factor {T}.
-Arguments Hashmap_hash_map_max_load {T}.
-Arguments Hashmap_hash_map_slots {T}.
+Arguments mkhashmap_HashMap_t {T} _ _ _ _.
+Arguments hashmap_HashMap_num_entries {T}.
+Arguments hashmap_HashMap_max_load_factor {T}.
+Arguments hashmap_HashMap_max_load {T}.
+Arguments hashmap_HashMap_slots {T}.
 
 (** The state type used in the state-error monad *)
 Axiom state : Type.
diff --git a/tests/coq/hashmap_on_disk/Primitives.v b/tests/coq/hashmap_on_disk/Primitives.v
index 8d6c9c8d..85e38f01 100644
--- a/tests/coq/hashmap_on_disk/Primitives.v
+++ b/tests/coq/hashmap_on_disk/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
 
 (*** Misc *)
 
-
 Definition string := Coq.Strings.String.string.
 Definition char := Coq.Strings.Ascii.ascii.
 Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
 
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
 
 (*** Scalars *)
 
@@ -408,12 +410,75 @@ Definition core_i64_max   := i64_max %i64.
 Definition core_i128_max  := i64_max %i128.
 Axiom core_isize_max : isize. (** TODO *)
 
-(*** Range *)
-Record range (T : Type) := mk_range {
-  start: T;
-  end_: T;
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+  core_ops_index_Index_Output : Type;
+  core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+  core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+  core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+  core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+  core_ops_deref_Deref_target : Type;
+  core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+  core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+  core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+  core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
 }.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+  core_ops_range_Range_start : T;
+  core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+  core_ops_deref_Deref_target := Self;
+  core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+  core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+  core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+  core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
 
 (*** Arrays *)
 Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -433,51 +498,50 @@ Qed.
 (* TODO: finish the definitions *)
 Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
 
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
 
 (*** Slice *)
 Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
 
 Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
 
 (*** Subslices *)
 
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
 
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
 
 (*** Vectors *)
 
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
 
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
 
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
 
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
 
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
 Proof.
-  unfold vec_length, usize_min.
+  unfold alloc_vec_Vec_length, usize_min.
   split.
   - lia.
   - apply (proj2_sig v).
 Qed.
 
-Definition vec_len (T: Type) (v: vec T) : usize :=
-  exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+  exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
 
 Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
   : list A :=
@@ -488,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
     | S m => x :: (list_update t m a)
 end end.
 
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
-  l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+  l <- f (alloc_vec_Vec_to_list v) ;
   match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
   | left H => Return (exist _ l (scalar_le_max_valid _ _ H))
   | right _ => Fail_ Failure
   end.
 
 (* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
 
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
-  vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
 
 (* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+  if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
 
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l =>
     if to_Z i <? Z.of_nat (length l)
     then Return (list_update l (usize_to_nat i) x)
     else Fail_ Failure).
 
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
-  end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+  core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+  core_slice_index_SliceIndex_Output : Type;
+  core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+  core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+  (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+  x <- inst.(core_slice_index_SliceIndex_get) i s;
+  match x with
+  | None => Fail_ Failure
+  | Some x => Return x
   end.
 
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
-    if to_Z i <? Z.of_nat (length l)
-    then Return (list_update l (usize_to_nat i) x)
-    else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+  (T : Type) :
+  core_ops_range_Range usize -> const_raw_ptr (slice T) -> result (const_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+     sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::get_unchecked_mut]: forward function *)
+Definition core_slice_index_Range_get_unchecked_mut
+  (T : Type) :
+  core_ops_range_Range usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+    sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::index]: forward function *)
+Axiom core_slice_index_Range_index :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (slice T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := slice T;
+  core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (slice T) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_Index (slice T) Idx) :
+  core_ops_index_Index (array T N) Idx := {|
+  core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+  core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_IndexMut (slice T) Idx) :
+  core_ops_index_IndexMut (array T N) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+  core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+  core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+  forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+  forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+  forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+  forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex usize (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := T;
+  core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+  core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+  alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+    alloc_vec_Vec_update_usize v i x.
 
 End Primitives.
diff --git a/tests/coq/misc/Constants.v b/tests/coq/misc/Constants.v
index 5dd78a09..7cb1a642 100644
--- a/tests/coq/misc/Constants.v
+++ b/tests/coq/misc/Constants.v
@@ -21,36 +21,35 @@ Definition x2_body : result u32 := Return 3%u32.
 Definition x2_c : u32 := x2_body%global.
 
 (** [constants::incr]: forward function *)
-Definition incr_fwd (n : u32) : result u32 :=
+Definition incr (n : u32) : result u32 :=
   u32_add n 1%u32.
 
 (** [constants::X3] *)
-Definition x3_body : result u32 := incr_fwd 32%u32.
+Definition x3_body : result u32 := incr 32%u32.
 Definition x3_c : u32 := x3_body%global.
 
 (** [constants::mk_pair0]: forward function *)
-Definition mk_pair0_fwd (x : u32) (y : u32) : result (u32 * u32) :=
-  Return (x, y)
-.
+Definition mk_pair0 (x : u32) (y : u32) : result (u32 * u32) :=
+  Return (x, y).
 
 (** [constants::Pair] *)
-Record Pair_t (T1 T2 : Type) := mkPair_t { Pair_x : T1; Pair_y : T2; }.
+Record Pair_t (T1 T2 : Type) := mkPair_t { pair_x : T1; pair_y : T2; }.
 
 Arguments mkPair_t {T1} {T2} _ _.
-Arguments Pair_x {T1} {T2}.
-Arguments Pair_y {T1} {T2}.
+Arguments pair_x {T1} {T2}.
+Arguments pair_y {T1} {T2}.
 
 (** [constants::mk_pair1]: forward function *)
-Definition mk_pair1_fwd (x : u32) (y : u32) : result (Pair_t u32 u32) :=
-  Return {| Pair_x := x; Pair_y := y |}
+Definition mk_pair1 (x : u32) (y : u32) : result (Pair_t u32 u32) :=
+  Return {| pair_x := x; pair_y := y |}
 .
 
 (** [constants::P0] *)
-Definition p0_body : result (u32 * u32) := mk_pair0_fwd 0%u32 1%u32.
+Definition p0_body : result (u32 * u32) := mk_pair0 0%u32 1%u32.
 Definition p0_c : (u32 * u32) := p0_body%global.
 
 (** [constants::P1] *)
-Definition p1_body : result (Pair_t u32 u32) := mk_pair1_fwd 0%u32 1%u32.
+Definition p1_body : result (Pair_t u32 u32) := mk_pair1 0%u32 1%u32.
 Definition p1_c : Pair_t u32 u32 := p1_body%global.
 
 (** [constants::P2] *)
@@ -59,31 +58,31 @@ Definition p2_c : (u32 * u32) := p2_body%global.
 
 (** [constants::P3] *)
 Definition p3_body : result (Pair_t u32 u32) :=
-  Return {| Pair_x := 0%u32; Pair_y := 1%u32 |}
+  Return {| pair_x := 0%u32; pair_y := 1%u32 |}
 .
 Definition p3_c : Pair_t u32 u32 := p3_body%global.
 
 (** [constants::Wrap] *)
-Record Wrap_t (T : Type) := mkWrap_t { Wrap_val : T; }.
+Record Wrap_t (T : Type) := mkWrap_t { wrap_value : T; }.
 
 Arguments mkWrap_t {T} _.
-Arguments Wrap_val {T}.
+Arguments wrap_value {T}.
 
 (** [constants::Wrap::{0}::new]: forward function *)
-Definition wrap_new_fwd (T : Type) (val : T) : result (Wrap_t T) :=
-  Return {| Wrap_val := val |}
+Definition wrap_new (T : Type) (value : T) : result (Wrap_t T) :=
+  Return {| wrap_value := value |}
 .
 
 (** [constants::Y] *)
-Definition y_body : result (Wrap_t i32) := wrap_new_fwd i32 2%i32.
+Definition y_body : result (Wrap_t i32) := wrap_new i32 2%i32.
 Definition y_c : Wrap_t i32 := y_body%global.
 
 (** [constants::unwrap_y]: forward function *)
-Definition unwrap_y_fwd : result i32 :=
-  Return y_c.(Wrap_val).
+Definition unwrap_y : result i32 :=
+  Return y_c.(wrap_value).
 
 (** [constants::YVAL] *)
-Definition yval_body : result i32 := unwrap_y_fwd.
+Definition yval_body : result i32 := unwrap_y.
 Definition yval_c : i32 := yval_body%global.
 
 (** [constants::get_z1::Z1] *)
@@ -91,11 +90,11 @@ Definition get_z1_z1_body : result i32 := Return 3%i32.
 Definition get_z1_z1_c : i32 := get_z1_z1_body%global.
 
 (** [constants::get_z1]: forward function *)
-Definition get_z1_fwd : result i32 :=
+Definition get_z1 : result i32 :=
   Return get_z1_z1_c.
 
 (** [constants::add]: forward function *)
-Definition add_fwd (a : i32) (b : i32) : result i32 :=
+Definition add (a : i32) (b : i32) : result i32 :=
   i32_add a b.
 
 (** [constants::Q1] *)
@@ -107,20 +106,19 @@ Definition q2_body : result i32 := Return q1_c.
 Definition q2_c : i32 := q2_body%global.
 
 (** [constants::Q3] *)
-Definition q3_body : result i32 := add_fwd q2_c 3%i32.
+Definition q3_body : result i32 := add q2_c 3%i32.
 Definition q3_c : i32 := q3_body%global.
 
 (** [constants::get_z2]: forward function *)
-Definition get_z2_fwd : result i32 :=
-  i <- get_z1_fwd; i0 <- add_fwd i q3_c; add_fwd q1_c i0
-.
+Definition get_z2 : result i32 :=
+  i <- get_z1; i0 <- add i q3_c; add q1_c i0.
 
 (** [constants::S1] *)
 Definition s1_body : result u32 := Return 6%u32.
 Definition s1_c : u32 := s1_body%global.
 
 (** [constants::S2] *)
-Definition s2_body : result u32 := incr_fwd s1_c.
+Definition s2_body : result u32 := incr s1_c.
 Definition s2_c : u32 := s2_body%global.
 
 (** [constants::S3] *)
@@ -128,7 +126,7 @@ Definition s3_body : result (Pair_t u32 u32) := Return p3_c.
 Definition s3_c : Pair_t u32 u32 := s3_body%global.
 
 (** [constants::S4] *)
-Definition s4_body : result (Pair_t u32 u32) := mk_pair1_fwd 7%u32 8%u32.
+Definition s4_body : result (Pair_t u32 u32) := mk_pair1 7%u32 8%u32.
 Definition s4_c : Pair_t u32 u32 := s4_body%global.
 
 End Constants .
diff --git a/tests/coq/misc/External_Funs.v b/tests/coq/misc/External_Funs.v
index 28370b2b..018ce13c 100644
--- a/tests/coq/misc/External_Funs.v
+++ b/tests/coq/misc/External_Funs.v
@@ -13,9 +13,9 @@ Import External_Opaque.
 Module External_Funs.
 
 (** [external::swap]: forward function *)
-Definition swap_fwd
+Definition swap
   (T : Type) (x : T) (y : T) (st : state) : result (state * unit) :=
-  p <- core_mem_swap_fwd T x y st;
+  p <- core_mem_swap T x y st;
   let (st0, _) := p in
   p0 <- core_mem_swap_back0 T x y st st0;
   let (st1, _) := p0 in
@@ -29,7 +29,7 @@ Definition swap_back
   (T : Type) (x : T) (y : T) (st : state) (st0 : state) :
   result (state * (T * T))
   :=
-  p <- core_mem_swap_fwd T x y st;
+  p <- core_mem_swap T x y st;
   let (st1, _) := p in
   p0 <- core_mem_swap_back0 T x y st st1;
   let (st2, x0) := p0 in
@@ -39,25 +39,27 @@ Definition swap_back
 .
 
 (** [external::test_new_non_zero_u32]: forward function *)
-Definition test_new_non_zero_u32_fwd
-  (x : u32) (st : state) : result (state * Core_num_nonzero_non_zero_u32_t) :=
-  p <- core_num_nonzero_non_zero_u32_new_fwd x st;
-  let (st0, opt) := p in
-  core_option_option_unwrap_fwd Core_num_nonzero_non_zero_u32_t opt st0
+Definition test_new_non_zero_u32
+  (x : u32) (st : state) : result (state * core_num_nonzero_NonZeroU32_t) :=
+  p <- core_num_nonzero_NonZeroU32_new x st;
+  let (st0, o) := p in
+  core_option_Option_unwrap core_num_nonzero_NonZeroU32_t o st0
 .
 
 (** [external::test_vec]: forward function *)
-Definition test_vec_fwd : result unit :=
-  let v := vec_new u32 in _ <- vec_push_back u32 v 0%u32; Return tt
+Definition test_vec : result unit :=
+  let v := alloc_vec_Vec_new u32 in
+  _ <- alloc_vec_Vec_push u32 v 0%u32;
+  Return tt
 .
 
 (** Unit test for [external::test_vec] *)
-Check (test_vec_fwd )%return.
+Check (test_vec )%return.
 
 (** [external::custom_swap]: forward function *)
-Definition custom_swap_fwd
+Definition custom_swap
   (T : Type) (x : T) (y : T) (st : state) : result (state * T) :=
-  p <- core_mem_swap_fwd T x y st;
+  p <- core_mem_swap T x y st;
   let (st0, _) := p in
   p0 <- core_mem_swap_back0 T x y st st0;
   let (st1, x0) := p0 in
@@ -71,7 +73,7 @@ Definition custom_swap_back
   (T : Type) (x : T) (y : T) (st : state) (ret : T) (st0 : state) :
   result (state * (T * T))
   :=
-  p <- core_mem_swap_fwd T x y st;
+  p <- core_mem_swap T x y st;
   let (st1, _) := p in
   p0 <- core_mem_swap_back0 T x y st st1;
   let (st2, _) := p0 in
@@ -81,9 +83,9 @@ Definition custom_swap_back
 .
 
 (** [external::test_custom_swap]: forward function *)
-Definition test_custom_swap_fwd
+Definition test_custom_swap
   (x : u32) (y : u32) (st : state) : result (state * unit) :=
-  p <- custom_swap_fwd u32 x y st; let (st0, _) := p in Return (st0, tt)
+  p <- custom_swap u32 x y st; let (st0, _) := p in Return (st0, tt)
 .
 
 (** [external::test_custom_swap]: backward function 0 *)
@@ -95,9 +97,8 @@ Definition test_custom_swap_back
 .
 
 (** [external::test_swap_non_zero]: forward function *)
-Definition test_swap_non_zero_fwd
-  (x : u32) (st : state) : result (state * u32) :=
-  p <- swap_fwd u32 x 0%u32 st;
+Definition test_swap_non_zero (x : u32) (st : state) : result (state * u32) :=
+  p <- swap u32 x 0%u32 st;
   let (st0, _) := p in
   p0 <- swap_back u32 x 0%u32 st st0;
   let (st1, p1) := p0 in
diff --git a/tests/coq/misc/External_Opaque.v b/tests/coq/misc/External_Opaque.v
index d2ee42d4..80be37e7 100644
--- a/tests/coq/misc/External_Opaque.v
+++ b/tests/coq/misc/External_Opaque.v
@@ -11,7 +11,7 @@ Import External_Types.
 Module External_Opaque.
 
 (** [core::mem::swap]: forward function *)
-Axiom core_mem_swap_fwd :
+Axiom core_mem_swap :
   forall(T : Type), T -> T -> state -> result (state * unit)
 .
 
@@ -26,12 +26,12 @@ Axiom core_mem_swap_back1 :
 .
 
 (** [core::num::nonzero::NonZeroU32::{14}::new]: forward function *)
-Axiom core_num_nonzero_non_zero_u32_new_fwd
-  : u32 -> state -> result (state * (option Core_num_nonzero_non_zero_u32_t))
+Axiom core_num_nonzero_NonZeroU32_new
+  : u32 -> state -> result (state * (option core_num_nonzero_NonZeroU32_t))
 .
 
 (** [core::option::Option::{0}::unwrap]: forward function *)
-Axiom core_option_option_unwrap_fwd :
+Axiom core_option_Option_unwrap :
   forall(T : Type), option T -> state -> result (state * T)
 .
 
diff --git a/tests/coq/misc/External_Types.v b/tests/coq/misc/External_Types.v
index 1883fa6c..9e49ca41 100644
--- a/tests/coq/misc/External_Types.v
+++ b/tests/coq/misc/External_Types.v
@@ -9,7 +9,7 @@ Local Open Scope Primitives_scope.
 Module External_Types.
 
 (** [core::num::nonzero::NonZeroU32] *)
-Axiom Core_num_nonzero_non_zero_u32_t : Type.
+Axiom core_num_nonzero_NonZeroU32_t : Type.
 
 (** The state type used in the state-error monad *)
 Axiom state : Type.
diff --git a/tests/coq/misc/Loops.v b/tests/coq/misc/Loops.v
index 82e57576..180a1d68 100644
--- a/tests/coq/misc/Loops.v
+++ b/tests/coq/misc/Loops.v
@@ -9,23 +9,23 @@ Local Open Scope Primitives_scope.
 Module Loops.
 
 (** [loops::sum]: loop 0: forward function *)
-Fixpoint sum_loop_fwd (n : nat) (max : u32) (i : u32) (s : u32) : result u32 :=
+Fixpoint sum_loop (n : nat) (max : u32) (i : u32) (s : u32) : result u32 :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     if i s< max
-    then (s0 <- u32_add s i; i0 <- u32_add i 1%u32; sum_loop_fwd n0 max i0 s0)
+    then (s0 <- u32_add s i; i0 <- u32_add i 1%u32; sum_loop n0 max i0 s0)
     else u32_mul s 2%u32
   end
 .
 
 (** [loops::sum]: forward function *)
-Definition sum_fwd (n : nat) (max : u32) : result u32 :=
-  sum_loop_fwd n max 0%u32 0%u32
+Definition sum (n : nat) (max : u32) : result u32 :=
+  sum_loop n max 0%u32 0%u32
 .
 
 (** [loops::sum_with_mut_borrows]: loop 0: forward function *)
-Fixpoint sum_with_mut_borrows_loop_fwd
+Fixpoint sum_with_mut_borrows_loop
   (n : nat) (max : u32) (mi : u32) (ms : u32) : result u32 :=
   match n with
   | O => Fail_ OutOfFuel
@@ -34,18 +34,18 @@ Fixpoint sum_with_mut_borrows_loop_fwd
     then (
       ms0 <- u32_add ms mi;
       mi0 <- u32_add mi 1%u32;
-      sum_with_mut_borrows_loop_fwd n0 max mi0 ms0)
+      sum_with_mut_borrows_loop n0 max mi0 ms0)
     else u32_mul ms 2%u32
   end
 .
 
 (** [loops::sum_with_mut_borrows]: forward function *)
-Definition sum_with_mut_borrows_fwd (n : nat) (max : u32) : result u32 :=
-  sum_with_mut_borrows_loop_fwd n max 0%u32 0%u32
+Definition sum_with_mut_borrows (n : nat) (max : u32) : result u32 :=
+  sum_with_mut_borrows_loop n max 0%u32 0%u32
 .
 
 (** [loops::sum_with_shared_borrows]: loop 0: forward function *)
-Fixpoint sum_with_shared_borrows_loop_fwd
+Fixpoint sum_with_shared_borrows_loop
   (n : nat) (max : u32) (i : u32) (s : u32) : result u32 :=
   match n with
   | O => Fail_ OutOfFuel
@@ -54,87 +54,88 @@ Fixpoint sum_with_shared_borrows_loop_fwd
     then (
       i0 <- u32_add i 1%u32;
       s0 <- u32_add s i0;
-      sum_with_shared_borrows_loop_fwd n0 max i0 s0)
+      sum_with_shared_borrows_loop n0 max i0 s0)
     else u32_mul s 2%u32
   end
 .
 
 (** [loops::sum_with_shared_borrows]: forward function *)
-Definition sum_with_shared_borrows_fwd (n : nat) (max : u32) : result u32 :=
-  sum_with_shared_borrows_loop_fwd n max 0%u32 0%u32
+Definition sum_with_shared_borrows (n : nat) (max : u32) : result u32 :=
+  sum_with_shared_borrows_loop n max 0%u32 0%u32
 .
 
 (** [loops::clear]: loop 0: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Fixpoint clear_loop_fwd_back
-  (n : nat) (v : vec u32) (i : usize) : result (vec u32) :=
+Fixpoint clear_loop
+  (n : nat) (v : alloc_vec_Vec u32) (i : usize) : result (alloc_vec_Vec u32) :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
-    let i0 := vec_len u32 v in
+    let i0 := alloc_vec_Vec_len u32 v in
     if i s< i0
     then (
       i1 <- usize_add i 1%usize;
-      v0 <- vec_index_mut_back u32 v i 0%u32;
-      clear_loop_fwd_back n0 v0 i1)
+      v0 <-
+        alloc_vec_Vec_index_mut_back u32 usize
+          (core_slice_index_usize_coresliceindexSliceIndexInst u32) v i 0%u32;
+      clear_loop n0 v0 i1)
     else Return v
   end
 .
 
 (** [loops::clear]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition clear_fwd_back (n : nat) (v : vec u32) : result (vec u32) :=
-  clear_loop_fwd_back n v 0%usize
+Definition clear
+  (n : nat) (v : alloc_vec_Vec u32) : result (alloc_vec_Vec u32) :=
+  clear_loop n v 0%usize
 .
 
 (** [loops::List] *)
 Inductive List_t (T : Type) :=
-| ListCons : T -> List_t T -> List_t T
-| ListNil : List_t T
+| List_Cons : T -> List_t T -> List_t T
+| List_Nil : List_t T
 .
 
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons {T} _ _.
+Arguments List_Nil {T}.
 
 (** [loops::list_mem]: loop 0: forward function *)
-Fixpoint list_mem_loop_fwd
-  (n : nat) (x : u32) (ls : List_t u32) : result bool :=
+Fixpoint list_mem_loop (n : nat) (x : u32) (ls : List_t u32) : result bool :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons y tl =>
-      if y s= x then Return true else list_mem_loop_fwd n0 x tl
-    | ListNil => Return false
+    | List_Cons y tl => if y s= x then Return true else list_mem_loop n0 x tl
+    | List_Nil => Return false
     end
   end
 .
 
 (** [loops::list_mem]: forward function *)
-Definition list_mem_fwd (n : nat) (x : u32) (ls : List_t u32) : result bool :=
-  list_mem_loop_fwd n x ls
+Definition list_mem (n : nat) (x : u32) (ls : List_t u32) : result bool :=
+  list_mem_loop n x ls
 .
 
 (** [loops::list_nth_mut_loop]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_loop_fwd
+Fixpoint list_nth_mut_loop_loop
   (T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons x tl =>
+    | List_Cons x tl =>
       if i s= 0%u32
       then Return x
-      else (i0 <- u32_sub i 1%u32; list_nth_mut_loop_loop_fwd T n0 tl i0)
-    | ListNil => Fail_ Failure
+      else (i0 <- u32_sub i 1%u32; list_nth_mut_loop_loop T n0 tl i0)
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_mut_loop]: forward function *)
-Definition list_nth_mut_loop_fwd
+Definition list_nth_mut_loop
   (T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
-  list_nth_mut_loop_loop_fwd T n ls i
+  list_nth_mut_loop_loop T n ls i
 .
 
 (** [loops::list_nth_mut_loop]: loop 0: backward function 0 *)
@@ -146,14 +147,14 @@ Fixpoint list_nth_mut_loop_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons x tl =>
+    | List_Cons x tl =>
       if i s= 0%u32
-      then Return (ListCons ret tl)
+      then Return (List_Cons ret tl)
       else (
         i0 <- u32_sub i 1%u32;
         tl0 <- list_nth_mut_loop_loop_back T n0 tl i0 ret;
-        Return (ListCons x tl0))
-    | ListNil => Fail_ Failure
+        Return (List_Cons x tl0))
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -167,46 +168,50 @@ Definition list_nth_mut_loop_back
 .
 
 (** [loops::list_nth_shared_loop]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_loop_fwd
+Fixpoint list_nth_shared_loop_loop
   (T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons x tl =>
+    | List_Cons x tl =>
       if i s= 0%u32
       then Return x
-      else (i0 <- u32_sub i 1%u32; list_nth_shared_loop_loop_fwd T n0 tl i0)
-    | ListNil => Fail_ Failure
+      else (i0 <- u32_sub i 1%u32; list_nth_shared_loop_loop T n0 tl i0)
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_shared_loop]: forward function *)
-Definition list_nth_shared_loop_fwd
+Definition list_nth_shared_loop
   (T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
-  list_nth_shared_loop_loop_fwd T n ls i
+  list_nth_shared_loop_loop T n ls i
 .
 
 (** [loops::get_elem_mut]: loop 0: forward function *)
-Fixpoint get_elem_mut_loop_fwd
+Fixpoint get_elem_mut_loop
   (n : nat) (x : usize) (ls : List_t usize) : result usize :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons y tl =>
-      if y s= x then Return y else get_elem_mut_loop_fwd n0 x tl
-    | ListNil => Fail_ Failure
+    | List_Cons y tl => if y s= x then Return y else get_elem_mut_loop n0 x tl
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::get_elem_mut]: forward function *)
-Definition get_elem_mut_fwd
-  (n : nat) (slots : vec (List_t usize)) (x : usize) : result usize :=
-  l <- vec_index_mut_fwd (List_t usize) slots 0%usize;
-  get_elem_mut_loop_fwd n x l
+Definition get_elem_mut
+  (n : nat) (slots : alloc_vec_Vec (List_t usize)) (x : usize) :
+  result usize
+  :=
+  l <-
+    alloc_vec_Vec_index_mut (List_t usize) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize))
+      slots 0%usize;
+  get_elem_mut_loop n x l
 .
 
 (** [loops::get_elem_mut]: loop 0: backward function 0 *)
@@ -218,50 +223,60 @@ Fixpoint get_elem_mut_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons y tl =>
+    | List_Cons y tl =>
       if y s= x
-      then Return (ListCons ret tl)
-      else (tl0 <- get_elem_mut_loop_back n0 x tl ret; Return (ListCons y tl0))
-    | ListNil => Fail_ Failure
+      then Return (List_Cons ret tl)
+      else (
+        tl0 <- get_elem_mut_loop_back n0 x tl ret; Return (List_Cons y tl0))
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::get_elem_mut]: backward function 0 *)
 Definition get_elem_mut_back
-  (n : nat) (slots : vec (List_t usize)) (x : usize) (ret : usize) :
-  result (vec (List_t usize))
+  (n : nat) (slots : alloc_vec_Vec (List_t usize)) (x : usize) (ret : usize) :
+  result (alloc_vec_Vec (List_t usize))
   :=
-  l <- vec_index_mut_fwd (List_t usize) slots 0%usize;
+  l <-
+    alloc_vec_Vec_index_mut (List_t usize) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize))
+      slots 0%usize;
   l0 <- get_elem_mut_loop_back n x l ret;
-  vec_index_mut_back (List_t usize) slots 0%usize l0
+  alloc_vec_Vec_index_mut_back (List_t usize) usize
+    (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize)) slots
+    0%usize l0
 .
 
 (** [loops::get_elem_shared]: loop 0: forward function *)
-Fixpoint get_elem_shared_loop_fwd
+Fixpoint get_elem_shared_loop
   (n : nat) (x : usize) (ls : List_t usize) : result usize :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons y tl =>
-      if y s= x then Return y else get_elem_shared_loop_fwd n0 x tl
-    | ListNil => Fail_ Failure
+    | List_Cons y tl =>
+      if y s= x then Return y else get_elem_shared_loop n0 x tl
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::get_elem_shared]: forward function *)
-Definition get_elem_shared_fwd
-  (n : nat) (slots : vec (List_t usize)) (x : usize) : result usize :=
-  l <- vec_index_fwd (List_t usize) slots 0%usize;
-  get_elem_shared_loop_fwd n x l
+Definition get_elem_shared
+  (n : nat) (slots : alloc_vec_Vec (List_t usize)) (x : usize) :
+  result usize
+  :=
+  l <-
+    alloc_vec_Vec_index (List_t usize) usize
+      (core_slice_index_usize_coresliceindexSliceIndexInst (List_t usize))
+      slots 0%usize;
+  get_elem_shared_loop n x l
 .
 
 (** [loops::id_mut]: forward function *)
-Definition id_mut_fwd (T : Type) (ls : List_t T) : result (List_t T) :=
-  Return ls
-.
+Definition id_mut (T : Type) (ls : List_t T) : result (List_t T) :=
+  Return ls.
 
 (** [loops::id_mut]: backward function 0 *)
 Definition id_mut_back
@@ -270,31 +285,30 @@ Definition id_mut_back
 .
 
 (** [loops::id_shared]: forward function *)
-Definition id_shared_fwd (T : Type) (ls : List_t T) : result (List_t T) :=
+Definition id_shared (T : Type) (ls : List_t T) : result (List_t T) :=
   Return ls
 .
 
 (** [loops::list_nth_mut_loop_with_id]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_with_id_loop_fwd
+Fixpoint list_nth_mut_loop_with_id_loop
   (T : Type) (n : nat) (i : u32) (ls : List_t T) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons x tl =>
+    | List_Cons x tl =>
       if i s= 0%u32
       then Return x
-      else (
-        i0 <- u32_sub i 1%u32; list_nth_mut_loop_with_id_loop_fwd T n0 i0 tl)
-    | ListNil => Fail_ Failure
+      else (i0 <- u32_sub i 1%u32; list_nth_mut_loop_with_id_loop T n0 i0 tl)
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_mut_loop_with_id]: forward function *)
-Definition list_nth_mut_loop_with_id_fwd
+Definition list_nth_mut_loop_with_id
   (T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
-  ls0 <- id_mut_fwd T ls; list_nth_mut_loop_with_id_loop_fwd T n i ls0
+  ls0 <- id_mut T ls; list_nth_mut_loop_with_id_loop T n i ls0
 .
 
 (** [loops::list_nth_mut_loop_with_id]: loop 0: backward function 0 *)
@@ -306,14 +320,14 @@ Fixpoint list_nth_mut_loop_with_id_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons x tl =>
+    | List_Cons x tl =>
       if i s= 0%u32
-      then Return (ListCons ret tl)
+      then Return (List_Cons ret tl)
       else (
         i0 <- u32_sub i 1%u32;
         tl0 <- list_nth_mut_loop_with_id_loop_back T n0 i0 tl ret;
-        Return (ListCons x tl0))
-    | ListNil => Fail_ Failure
+        Return (List_Cons x tl0))
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -323,36 +337,36 @@ Definition list_nth_mut_loop_with_id_back
   (T : Type) (n : nat) (ls : List_t T) (i : u32) (ret : T) :
   result (List_t T)
   :=
-  ls0 <- id_mut_fwd T ls;
+  ls0 <- id_mut T ls;
   l <- list_nth_mut_loop_with_id_loop_back T n i ls0 ret;
   id_mut_back T ls l
 .
 
 (** [loops::list_nth_shared_loop_with_id]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_with_id_loop_fwd
+Fixpoint list_nth_shared_loop_with_id_loop
   (T : Type) (n : nat) (i : u32) (ls : List_t T) : result T :=
   match n with
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls with
-    | ListCons x tl =>
+    | List_Cons x tl =>
       if i s= 0%u32
       then Return x
       else (
-        i0 <- u32_sub i 1%u32; list_nth_shared_loop_with_id_loop_fwd T n0 i0 tl)
-    | ListNil => Fail_ Failure
+        i0 <- u32_sub i 1%u32; list_nth_shared_loop_with_id_loop T n0 i0 tl)
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_shared_loop_with_id]: forward function *)
-Definition list_nth_shared_loop_with_id_fwd
+Definition list_nth_shared_loop_with_id
   (T : Type) (n : nat) (ls : List_t T) (i : u32) : result T :=
-  ls0 <- id_shared_fwd T ls; list_nth_shared_loop_with_id_loop_fwd T n i ls0
+  ls0 <- id_shared T ls; list_nth_shared_loop_with_id_loop T n i ls0
 .
 
 (** [loops::list_nth_mut_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_pair_loop_fwd
+Fixpoint list_nth_mut_loop_pair_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -360,27 +374,26 @@ Fixpoint list_nth_mut_loop_pair_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
-          i0 <- u32_sub i 1%u32;
-          list_nth_mut_loop_pair_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          i0 <- u32_sub i 1%u32; list_nth_mut_loop_pair_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_mut_loop_pair]: forward function *)
-Definition list_nth_mut_loop_pair_fwd
+Definition list_nth_mut_loop_pair
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_mut_loop_pair_loop_fwd T n ls0 ls1 i
+  list_nth_mut_loop_pair_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_mut_loop_pair]: loop 0: backward function 0 *)
@@ -392,18 +405,18 @@ Fixpoint list_nth_mut_loop_pair_loop_back'a
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
-        then Return (ListCons ret tl0)
+        then Return (List_Cons ret tl0)
         else (
           i0 <- u32_sub i 1%u32;
           tl00 <- list_nth_mut_loop_pair_loop_back'a T n0 tl0 tl1 i0 ret;
-          Return (ListCons x0 tl00))
-      | ListNil => Fail_ Failure
+          Return (List_Cons x0 tl00))
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -425,18 +438,18 @@ Fixpoint list_nth_mut_loop_pair_loop_back'b
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
-        then Return (ListCons ret tl1)
+        then Return (List_Cons ret tl1)
         else (
           i0 <- u32_sub i 1%u32;
           tl10 <- list_nth_mut_loop_pair_loop_back'b T n0 tl0 tl1 i0 ret;
-          Return (ListCons x1 tl10))
-      | ListNil => Fail_ Failure
+          Return (List_Cons x1 tl10))
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -450,7 +463,7 @@ Definition list_nth_mut_loop_pair_back'b
 .
 
 (** [loops::list_nth_shared_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_pair_loop_fwd
+Fixpoint list_nth_shared_loop_pair_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -458,31 +471,30 @@ Fixpoint list_nth_shared_loop_pair_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
-          i0 <- u32_sub i 1%u32;
-          list_nth_shared_loop_pair_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          i0 <- u32_sub i 1%u32; list_nth_shared_loop_pair_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_shared_loop_pair]: forward function *)
-Definition list_nth_shared_loop_pair_fwd
+Definition list_nth_shared_loop_pair
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_shared_loop_pair_loop_fwd T n ls0 ls1 i
+  list_nth_shared_loop_pair_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_mut_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_mut_loop_pair_merge_loop_fwd
+Fixpoint list_nth_mut_loop_pair_merge_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -490,27 +502,27 @@ Fixpoint list_nth_mut_loop_pair_merge_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
           i0 <- u32_sub i 1%u32;
-          list_nth_mut_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          list_nth_mut_loop_pair_merge_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_mut_loop_pair_merge]: forward function *)
-Definition list_nth_mut_loop_pair_merge_fwd
+Definition list_nth_mut_loop_pair_merge
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_mut_loop_pair_merge_loop_fwd T n ls0 ls1 i
+  list_nth_mut_loop_pair_merge_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_mut_loop_pair_merge]: loop 0: backward function 0 *)
@@ -523,19 +535,19 @@ Fixpoint list_nth_mut_loop_pair_merge_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
-        then let (t, t0) := ret in Return (ListCons t tl0, ListCons t0 tl1)
+        then let (t, t0) := ret in Return (List_Cons t tl0, List_Cons t0 tl1)
         else (
           i0 <- u32_sub i 1%u32;
           p <- list_nth_mut_loop_pair_merge_loop_back T n0 tl0 tl1 i0 ret;
           let (tl00, tl10) := p in
-          Return (ListCons x0 tl00, ListCons x1 tl10))
-      | ListNil => Fail_ Failure
+          Return (List_Cons x0 tl00, List_Cons x1 tl10))
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -550,7 +562,7 @@ Definition list_nth_mut_loop_pair_merge_back
 .
 
 (** [loops::list_nth_shared_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_shared_loop_pair_merge_loop_fwd
+Fixpoint list_nth_shared_loop_pair_merge_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -558,31 +570,31 @@ Fixpoint list_nth_shared_loop_pair_merge_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
           i0 <- u32_sub i 1%u32;
-          list_nth_shared_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          list_nth_shared_loop_pair_merge_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_shared_loop_pair_merge]: forward function *)
-Definition list_nth_shared_loop_pair_merge_fwd
+Definition list_nth_shared_loop_pair_merge
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_shared_loop_pair_merge_loop_fwd T n ls0 ls1 i
+  list_nth_shared_loop_pair_merge_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_mut_shared_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_mut_shared_loop_pair_loop_fwd
+Fixpoint list_nth_mut_shared_loop_pair_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -590,27 +602,27 @@ Fixpoint list_nth_mut_shared_loop_pair_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
           i0 <- u32_sub i 1%u32;
-          list_nth_mut_shared_loop_pair_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          list_nth_mut_shared_loop_pair_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_mut_shared_loop_pair]: forward function *)
-Definition list_nth_mut_shared_loop_pair_fwd
+Definition list_nth_mut_shared_loop_pair
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_mut_shared_loop_pair_loop_fwd T n ls0 ls1 i
+  list_nth_mut_shared_loop_pair_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_mut_shared_loop_pair]: loop 0: backward function 0 *)
@@ -622,18 +634,18 @@ Fixpoint list_nth_mut_shared_loop_pair_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
-        then Return (ListCons ret tl0)
+        then Return (List_Cons ret tl0)
         else (
           i0 <- u32_sub i 1%u32;
           tl00 <- list_nth_mut_shared_loop_pair_loop_back T n0 tl0 tl1 i0 ret;
-          Return (ListCons x0 tl00))
-      | ListNil => Fail_ Failure
+          Return (List_Cons x0 tl00))
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -647,7 +659,7 @@ Definition list_nth_mut_shared_loop_pair_back
 .
 
 (** [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_mut_shared_loop_pair_merge_loop_fwd
+Fixpoint list_nth_mut_shared_loop_pair_merge_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -655,27 +667,27 @@ Fixpoint list_nth_mut_shared_loop_pair_merge_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
           i0 <- u32_sub i 1%u32;
-          list_nth_mut_shared_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          list_nth_mut_shared_loop_pair_merge_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_mut_shared_loop_pair_merge]: forward function *)
-Definition list_nth_mut_shared_loop_pair_merge_fwd
+Definition list_nth_mut_shared_loop_pair_merge
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_mut_shared_loop_pair_merge_loop_fwd T n ls0 ls1 i
+  list_nth_mut_shared_loop_pair_merge_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: backward function 0 *)
@@ -687,19 +699,19 @@ Fixpoint list_nth_mut_shared_loop_pair_merge_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
-        then Return (ListCons ret tl0)
+        then Return (List_Cons ret tl0)
         else (
           i0 <- u32_sub i 1%u32;
           tl00 <-
             list_nth_mut_shared_loop_pair_merge_loop_back T n0 tl0 tl1 i0 ret;
-          Return (ListCons x0 tl00))
-      | ListNil => Fail_ Failure
+          Return (List_Cons x0 tl00))
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -713,7 +725,7 @@ Definition list_nth_mut_shared_loop_pair_merge_back
 .
 
 (** [loops::list_nth_shared_mut_loop_pair]: loop 0: forward function *)
-Fixpoint list_nth_shared_mut_loop_pair_loop_fwd
+Fixpoint list_nth_shared_mut_loop_pair_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -721,27 +733,27 @@ Fixpoint list_nth_shared_mut_loop_pair_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
           i0 <- u32_sub i 1%u32;
-          list_nth_shared_mut_loop_pair_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          list_nth_shared_mut_loop_pair_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_shared_mut_loop_pair]: forward function *)
-Definition list_nth_shared_mut_loop_pair_fwd
+Definition list_nth_shared_mut_loop_pair
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_shared_mut_loop_pair_loop_fwd T n ls0 ls1 i
+  list_nth_shared_mut_loop_pair_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_shared_mut_loop_pair]: loop 0: backward function 1 *)
@@ -753,18 +765,18 @@ Fixpoint list_nth_shared_mut_loop_pair_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
-        then Return (ListCons ret tl1)
+        then Return (List_Cons ret tl1)
         else (
           i0 <- u32_sub i 1%u32;
           tl10 <- list_nth_shared_mut_loop_pair_loop_back T n0 tl0 tl1 i0 ret;
-          Return (ListCons x1 tl10))
-      | ListNil => Fail_ Failure
+          Return (List_Cons x1 tl10))
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
@@ -778,7 +790,7 @@ Definition list_nth_shared_mut_loop_pair_back
 .
 
 (** [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: forward function *)
-Fixpoint list_nth_shared_mut_loop_pair_merge_loop_fwd
+Fixpoint list_nth_shared_mut_loop_pair_merge_loop
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
@@ -786,27 +798,27 @@ Fixpoint list_nth_shared_mut_loop_pair_merge_loop_fwd
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
         then Return (x0, x1)
         else (
           i0 <- u32_sub i 1%u32;
-          list_nth_shared_mut_loop_pair_merge_loop_fwd T n0 tl0 tl1 i0)
-      | ListNil => Fail_ Failure
+          list_nth_shared_mut_loop_pair_merge_loop T n0 tl0 tl1 i0)
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
 
 (** [loops::list_nth_shared_mut_loop_pair_merge]: forward function *)
-Definition list_nth_shared_mut_loop_pair_merge_fwd
+Definition list_nth_shared_mut_loop_pair_merge
   (T : Type) (n : nat) (ls0 : List_t T) (ls1 : List_t T) (i : u32) :
   result (T * T)
   :=
-  list_nth_shared_mut_loop_pair_merge_loop_fwd T n ls0 ls1 i
+  list_nth_shared_mut_loop_pair_merge_loop T n ls0 ls1 i
 .
 
 (** [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: backward function 0 *)
@@ -818,19 +830,19 @@ Fixpoint list_nth_shared_mut_loop_pair_merge_loop_back
   | O => Fail_ OutOfFuel
   | S n0 =>
     match ls0 with
-    | ListCons x0 tl0 =>
+    | List_Cons x0 tl0 =>
       match ls1 with
-      | ListCons x1 tl1 =>
+      | List_Cons x1 tl1 =>
         if i s= 0%u32
-        then Return (ListCons ret tl1)
+        then Return (List_Cons ret tl1)
         else (
           i0 <- u32_sub i 1%u32;
           tl10 <-
             list_nth_shared_mut_loop_pair_merge_loop_back T n0 tl0 tl1 i0 ret;
-          Return (ListCons x1 tl10))
-      | ListNil => Fail_ Failure
+          Return (List_Cons x1 tl10))
+      | List_Nil => Fail_ Failure
       end
-    | ListNil => Fail_ Failure
+    | List_Nil => Fail_ Failure
     end
   end
 .
diff --git a/tests/coq/misc/NoNestedBorrows.v b/tests/coq/misc/NoNestedBorrows.v
index c1c24e00..47cdc3af 100644
--- a/tests/coq/misc/NoNestedBorrows.v
+++ b/tests/coq/misc/NoNestedBorrows.v
@@ -9,113 +9,113 @@ Local Open Scope Primitives_scope.
 Module NoNestedBorrows.
 
 (** [no_nested_borrows::Pair] *)
-Record Pair_t (T1 T2 : Type) := mkPair_t { Pair_x : T1; Pair_y : T2; }.
+Record Pair_t (T1 T2 : Type) := mkPair_t { pair_x : T1; pair_y : T2; }.
 
 Arguments mkPair_t {T1} {T2} _ _.
-Arguments Pair_x {T1} {T2}.
-Arguments Pair_y {T1} {T2}.
+Arguments pair_x {T1} {T2}.
+Arguments pair_y {T1} {T2}.
 
 (** [no_nested_borrows::List] *)
 Inductive List_t (T : Type) :=
-| ListCons : T -> List_t T -> List_t T
-| ListNil : List_t T
+| List_Cons : T -> List_t T -> List_t T
+| List_Nil : List_t T
 .
 
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons {T} _ _.
+Arguments List_Nil {T}.
 
 (** [no_nested_borrows::One] *)
-Inductive One_t (T1 : Type) := | OneOne : T1 -> One_t T1.
+Inductive One_t (T1 : Type) := | One_One : T1 -> One_t T1.
 
-Arguments OneOne {T1} _.
+Arguments One_One {T1} _.
 
 (** [no_nested_borrows::EmptyEnum] *)
-Inductive Empty_enum_t := | EmptyEnumEmpty : Empty_enum_t.
+Inductive EmptyEnum_t := | EmptyEnum_Empty : EmptyEnum_t.
 
 (** [no_nested_borrows::Enum] *)
-Inductive Enum_t := | EnumVariant1 : Enum_t | EnumVariant2 : Enum_t.
+Inductive Enum_t := | Enum_Variant1 : Enum_t | Enum_Variant2 : Enum_t.
 
 (** [no_nested_borrows::EmptyStruct] *)
-Record Empty_struct_t := mkEmpty_struct_t {  }.
+Record EmptyStruct_t := mkEmptyStruct_t {  }.
 
 (** [no_nested_borrows::Sum] *)
 Inductive Sum_t (T1 T2 : Type) :=
-| SumLeft : T1 -> Sum_t T1 T2
-| SumRight : T2 -> Sum_t T1 T2
+| Sum_Left : T1 -> Sum_t T1 T2
+| Sum_Right : T2 -> Sum_t T1 T2
 .
 
-Arguments SumLeft {T1} {T2} _.
-Arguments SumRight {T1} {T2} _.
+Arguments Sum_Left {T1} {T2} _.
+Arguments Sum_Right {T1} {T2} _.
 
 (** [no_nested_borrows::neg_test]: forward function *)
-Definition neg_test_fwd (x : i32) : result i32 :=
+Definition neg_test (x : i32) : result i32 :=
   i32_neg x.
 
 (** [no_nested_borrows::add_test]: forward function *)
-Definition add_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition add_test (x : u32) (y : u32) : result u32 :=
   u32_add x y.
 
 (** [no_nested_borrows::subs_test]: forward function *)
-Definition subs_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition subs_test (x : u32) (y : u32) : result u32 :=
   u32_sub x y.
 
 (** [no_nested_borrows::div_test]: forward function *)
-Definition div_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition div_test (x : u32) (y : u32) : result u32 :=
   u32_div x y.
 
 (** [no_nested_borrows::div_test1]: forward function *)
-Definition div_test1_fwd (x : u32) : result u32 :=
+Definition div_test1 (x : u32) : result u32 :=
   u32_div x 2%u32.
 
 (** [no_nested_borrows::rem_test]: forward function *)
-Definition rem_test_fwd (x : u32) (y : u32) : result u32 :=
+Definition rem_test (x : u32) (y : u32) : result u32 :=
   u32_rem x y.
 
 (** [no_nested_borrows::cast_test]: forward function *)
-Definition cast_test_fwd (x : u32) : result i32 :=
+Definition cast_test (x : u32) : result i32 :=
   scalar_cast U32 I32 x.
 
 (** [no_nested_borrows::test2]: forward function *)
-Definition test2_fwd : result unit :=
+Definition test2 : result unit :=
   _ <- u32_add 23%u32 44%u32; Return tt.
 
 (** Unit test for [no_nested_borrows::test2] *)
-Check (test2_fwd )%return.
+Check (test2 )%return.
 
 (** [no_nested_borrows::get_max]: forward function *)
-Definition get_max_fwd (x : u32) (y : u32) : result u32 :=
+Definition get_max (x : u32) (y : u32) : result u32 :=
   if x s>= y then Return x else Return y
 .
 
 (** [no_nested_borrows::test3]: forward function *)
-Definition test3_fwd : result unit :=
-  x <- get_max_fwd 4%u32 3%u32;
-  y <- get_max_fwd 10%u32 11%u32;
+Definition test3 : result unit :=
+  x <- get_max 4%u32 3%u32;
+  y <- get_max 10%u32 11%u32;
   z <- u32_add x y;
   if negb (z s= 15%u32) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [no_nested_borrows::test3] *)
-Check (test3_fwd )%return.
+Check (test3 )%return.
 
 (** [no_nested_borrows::test_neg1]: forward function *)
-Definition test_neg1_fwd : result unit :=
+Definition test_neg1 : result unit :=
   y <- i32_neg 3%i32; if negb (y s= (-3)%i32) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [no_nested_borrows::test_neg1] *)
-Check (test_neg1_fwd )%return.
+Check (test_neg1 )%return.
 
 (** [no_nested_borrows::refs_test1]: forward function *)
-Definition refs_test1_fwd : result unit :=
+Definition refs_test1 : result unit :=
   if negb (1%i32 s= 1%i32) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [no_nested_borrows::refs_test1] *)
-Check (refs_test1_fwd )%return.
+Check (refs_test1 )%return.
 
 (** [no_nested_borrows::refs_test2]: forward function *)
-Definition refs_test2_fwd : result unit :=
+Definition refs_test2 : result unit :=
   if negb (2%i32 s= 2%i32)
   then Fail_ Failure
   else
@@ -128,85 +128,83 @@ Definition refs_test2_fwd : result unit :=
 .
 
 (** Unit test for [no_nested_borrows::refs_test2] *)
-Check (refs_test2_fwd )%return.
+Check (refs_test2 )%return.
 
 (** [no_nested_borrows::test_list1]: forward function *)
-Definition test_list1_fwd : result unit :=
+Definition test_list1 : result unit :=
   Return tt.
 
 (** Unit test for [no_nested_borrows::test_list1] *)
-Check (test_list1_fwd )%return.
+Check (test_list1 )%return.
 
 (** [no_nested_borrows::test_box1]: forward function *)
-Definition test_box1_fwd : result unit :=
+Definition test_box1 : result unit :=
   let b := 1%i32 in
   let x := b in
   if negb (x s= 1%i32) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [no_nested_borrows::test_box1] *)
-Check (test_box1_fwd )%return.
+Check (test_box1 )%return.
 
 (** [no_nested_borrows::copy_int]: forward function *)
-Definition copy_int_fwd (x : i32) : result i32 :=
+Definition copy_int (x : i32) : result i32 :=
   Return x.
 
 (** [no_nested_borrows::test_unreachable]: forward function *)
-Definition test_unreachable_fwd (b : bool) : result unit :=
+Definition test_unreachable (b : bool) : result unit :=
   if b then Fail_ Failure else Return tt
 .
 
 (** [no_nested_borrows::test_panic]: forward function *)
-Definition test_panic_fwd (b : bool) : result unit :=
+Definition test_panic (b : bool) : result unit :=
   if b then Fail_ Failure else Return tt
 .
 
 (** [no_nested_borrows::test_copy_int]: forward function *)
-Definition test_copy_int_fwd : result unit :=
-  y <- copy_int_fwd 0%i32;
-  if negb (0%i32 s= y) then Fail_ Failure else Return tt
+Definition test_copy_int : result unit :=
+  y <- copy_int 0%i32; if negb (0%i32 s= y) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [no_nested_borrows::test_copy_int] *)
-Check (test_copy_int_fwd )%return.
+Check (test_copy_int )%return.
 
 (** [no_nested_borrows::is_cons]: forward function *)
-Definition is_cons_fwd (T : Type) (l : List_t T) : result bool :=
-  match l with | ListCons t l0 => Return true | ListNil => Return false end
+Definition is_cons (T : Type) (l : List_t T) : result bool :=
+  match l with | List_Cons t l0 => Return true | List_Nil => Return false end
 .
 
 (** [no_nested_borrows::test_is_cons]: forward function *)
-Definition test_is_cons_fwd : result unit :=
-  let l := ListNil in
-  b <- is_cons_fwd i32 (ListCons 0%i32 l);
+Definition test_is_cons : result unit :=
+  let l := List_Nil in
+  b <- is_cons i32 (List_Cons 0%i32 l);
   if negb b then Fail_ Failure else Return tt
 .
 
 (** Unit test for [no_nested_borrows::test_is_cons] *)
-Check (test_is_cons_fwd )%return.
+Check (test_is_cons )%return.
 
 (** [no_nested_borrows::split_list]: forward function *)
-Definition split_list_fwd
-  (T : Type) (l : List_t T) : result (T * (List_t T)) :=
+Definition split_list (T : Type) (l : List_t T) : result (T * (List_t T)) :=
   match l with
-  | ListCons hd tl => Return (hd, tl)
-  | ListNil => Fail_ Failure
+  | List_Cons hd tl => Return (hd, tl)
+  | List_Nil => Fail_ Failure
   end
 .
 
 (** [no_nested_borrows::test_split_list]: forward function *)
-Definition test_split_list_fwd : result unit :=
-  let l := ListNil in
-  p <- split_list_fwd i32 (ListCons 0%i32 l);
+Definition test_split_list : result unit :=
+  let l := List_Nil in
+  p <- split_list i32 (List_Cons 0%i32 l);
   let (hd, _) := p in
   if negb (hd s= 0%i32) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [no_nested_borrows::test_split_list] *)
-Check (test_split_list_fwd )%return.
+Check (test_split_list )%return.
 
 (** [no_nested_borrows::choose]: forward function *)
-Definition choose_fwd (T : Type) (b : bool) (x : T) (y : T) : result T :=
+Definition choose (T : Type) (b : bool) (x : T) (y : T) : result T :=
   if b then Return x else Return y
 .
 
@@ -217,8 +215,8 @@ Definition choose_back
 .
 
 (** [no_nested_borrows::choose_test]: forward function *)
-Definition choose_test_fwd : result unit :=
-  z <- choose_fwd i32 true 0%i32 0%i32;
+Definition choose_test : result unit :=
+  z <- choose i32 true 0%i32 0%i32;
   z0 <- i32_add z 1%i32;
   if negb (z0 s= 1%i32)
   then Fail_ Failure
@@ -231,57 +229,56 @@ Definition choose_test_fwd : result unit :=
 .
 
 (** Unit test for [no_nested_borrows::choose_test] *)
-Check (choose_test_fwd )%return.
+Check (choose_test )%return.
 
 (** [no_nested_borrows::test_char]: forward function *)
-Definition test_char_fwd : result char :=
-  Return (char_of_byte Coq.Init.Byte.x61)
-.
+Definition test_char : result char :=
+  Return (char_of_byte Coq.Init.Byte.x61).
 
 (** [no_nested_borrows::Tree] *)
 Inductive Tree_t (T : Type) :=
-| TreeLeaf : T -> Tree_t T
-| TreeNode : T -> Node_elem_t T -> Tree_t T -> Tree_t T
+| Tree_Leaf : T -> Tree_t T
+| Tree_Node : T -> NodeElem_t T -> Tree_t T -> Tree_t T
 
 (** [no_nested_borrows::NodeElem] *)
-with Node_elem_t (T : Type) :=
-| NodeElemCons : Tree_t T -> Node_elem_t T -> Node_elem_t T
-| NodeElemNil : Node_elem_t T
+with NodeElem_t (T : Type) :=
+| NodeElem_Cons : Tree_t T -> NodeElem_t T -> NodeElem_t T
+| NodeElem_Nil : NodeElem_t T
 .
 
-Arguments TreeLeaf {T} _.
-Arguments TreeNode {T} _ _ _.
+Arguments Tree_Leaf {T} _.
+Arguments Tree_Node {T} _ _ _.
 
-Arguments NodeElemCons {T} _ _.
-Arguments NodeElemNil {T}.
+Arguments NodeElem_Cons {T} _ _.
+Arguments NodeElem_Nil {T}.
 
 (** [no_nested_borrows::list_length]: forward function *)
-Fixpoint list_length_fwd (T : Type) (l : List_t T) : result u32 :=
+Fixpoint list_length (T : Type) (l : List_t T) : result u32 :=
   match l with
-  | ListCons t l1 => i <- list_length_fwd T l1; u32_add 1%u32 i
-  | ListNil => Return 0%u32
+  | List_Cons t l1 => i <- list_length T l1; u32_add 1%u32 i
+  | List_Nil => Return 0%u32
   end
 .
 
 (** [no_nested_borrows::list_nth_shared]: forward function *)
-Fixpoint list_nth_shared_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
+Fixpoint list_nth_shared (T : Type) (l : List_t T) (i : u32) : result T :=
   match l with
-  | ListCons x tl =>
+  | List_Cons x tl =>
     if i s= 0%u32
     then Return x
-    else (i0 <- u32_sub i 1%u32; list_nth_shared_fwd T tl i0)
-  | ListNil => Fail_ Failure
+    else (i0 <- u32_sub i 1%u32; list_nth_shared T tl i0)
+  | List_Nil => Fail_ Failure
   end
 .
 
 (** [no_nested_borrows::list_nth_mut]: forward function *)
-Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
+Fixpoint list_nth_mut (T : Type) (l : List_t T) (i : u32) : result T :=
   match l with
-  | ListCons x tl =>
+  | List_Cons x tl =>
     if i s= 0%u32
     then Return x
-    else (i0 <- u32_sub i 1%u32; list_nth_mut_fwd T tl i0)
-  | ListNil => Fail_ Failure
+    else (i0 <- u32_sub i 1%u32; list_nth_mut T tl i0)
+  | List_Nil => Fail_ Failure
   end
 .
 
@@ -289,73 +286,72 @@ Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
 Fixpoint list_nth_mut_back
   (T : Type) (l : List_t T) (i : u32) (ret : T) : result (List_t T) :=
   match l with
-  | ListCons x tl =>
+  | List_Cons x tl =>
     if i s= 0%u32
-    then Return (ListCons ret tl)
+    then Return (List_Cons ret tl)
     else (
       i0 <- u32_sub i 1%u32;
       tl0 <- list_nth_mut_back T tl i0 ret;
-      Return (ListCons x tl0))
-  | ListNil => Fail_ Failure
+      Return (List_Cons x tl0))
+  | List_Nil => Fail_ Failure
   end
 .
 
 (** [no_nested_borrows::list_rev_aux]: forward function *)
-Fixpoint list_rev_aux_fwd
+Fixpoint list_rev_aux
   (T : Type) (li : List_t T) (lo : List_t T) : result (List_t T) :=
   match li with
-  | ListCons hd tl => list_rev_aux_fwd T tl (ListCons hd lo)
-  | ListNil => Return lo
+  | List_Cons hd tl => list_rev_aux T tl (List_Cons hd lo)
+  | List_Nil => Return lo
   end
 .
 
 (** [no_nested_borrows::list_rev]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition list_rev_fwd_back (T : Type) (l : List_t T) : result (List_t T) :=
-  let li := mem_replace_fwd (List_t T) l ListNil in
-  list_rev_aux_fwd T li ListNil
+Definition list_rev (T : Type) (l : List_t T) : result (List_t T) :=
+  let li := core_mem_replace (List_t T) l List_Nil in
+  list_rev_aux T li List_Nil
 .
 
 (** [no_nested_borrows::test_list_functions]: forward function *)
-Definition test_list_functions_fwd : result unit :=
-  let l := ListNil in
-  let l0 := ListCons 2%i32 l in
-  let l1 := ListCons 1%i32 l0 in
-  i <- list_length_fwd i32 (ListCons 0%i32 l1);
+Definition test_list_functions : result unit :=
+  let l := List_Nil in
+  let l0 := List_Cons 2%i32 l in
+  let l1 := List_Cons 1%i32 l0 in
+  i <- list_length i32 (List_Cons 0%i32 l1);
   if negb (i s= 3%u32)
   then Fail_ Failure
   else (
-    i0 <- list_nth_shared_fwd i32 (ListCons 0%i32 l1) 0%u32;
+    i0 <- list_nth_shared i32 (List_Cons 0%i32 l1) 0%u32;
     if negb (i0 s= 0%i32)
     then Fail_ Failure
     else (
-      i1 <- list_nth_shared_fwd i32 (ListCons 0%i32 l1) 1%u32;
+      i1 <- list_nth_shared i32 (List_Cons 0%i32 l1) 1%u32;
       if negb (i1 s= 1%i32)
       then Fail_ Failure
       else (
-        i2 <- list_nth_shared_fwd i32 (ListCons 0%i32 l1) 2%u32;
+        i2 <- list_nth_shared i32 (List_Cons 0%i32 l1) 2%u32;
         if negb (i2 s= 2%i32)
         then Fail_ Failure
         else (
-          ls <- list_nth_mut_back i32 (ListCons 0%i32 l1) 1%u32 3%i32;
-          i3 <- list_nth_shared_fwd i32 ls 0%u32;
+          ls <- list_nth_mut_back i32 (List_Cons 0%i32 l1) 1%u32 3%i32;
+          i3 <- list_nth_shared i32 ls 0%u32;
           if negb (i3 s= 0%i32)
           then Fail_ Failure
           else (
-            i4 <- list_nth_shared_fwd i32 ls 1%u32;
+            i4 <- list_nth_shared i32 ls 1%u32;
             if negb (i4 s= 3%i32)
             then Fail_ Failure
             else (
-              i5 <- list_nth_shared_fwd i32 ls 2%u32;
+              i5 <- list_nth_shared i32 ls 2%u32;
               if negb (i5 s= 2%i32) then Fail_ Failure else Return tt))))))
 .
 
 (** Unit test for [no_nested_borrows::test_list_functions] *)
-Check (test_list_functions_fwd )%return.
+Check (test_list_functions )%return.
 
 (** [no_nested_borrows::id_mut_pair1]: forward function *)
-Definition id_mut_pair1_fwd
-  (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
+Definition id_mut_pair1 (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
   Return (x, y)
 .
 
@@ -366,8 +362,7 @@ Definition id_mut_pair1_back
 .
 
 (** [no_nested_borrows::id_mut_pair2]: forward function *)
-Definition id_mut_pair2_fwd
-  (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
+Definition id_mut_pair2 (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
   let (t, t0) := p in Return (t, t0)
 .
 
@@ -378,8 +373,7 @@ Definition id_mut_pair2_back
 .
 
 (** [no_nested_borrows::id_mut_pair3]: forward function *)
-Definition id_mut_pair3_fwd
-  (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
+Definition id_mut_pair3 (T1 T2 : Type) (x : T1) (y : T2) : result (T1 * T2) :=
   Return (x, y)
 .
 
@@ -396,8 +390,7 @@ Definition id_mut_pair3_back'b
 .
 
 (** [no_nested_borrows::id_mut_pair4]: forward function *)
-Definition id_mut_pair4_fwd
-  (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
+Definition id_mut_pair4 (T1 T2 : Type) (p : (T1 * T2)) : result (T1 * T2) :=
   let (t, t0) := p in Return (t, t0)
 .
 
@@ -414,101 +407,101 @@ Definition id_mut_pair4_back'b
 .
 
 (** [no_nested_borrows::StructWithTuple] *)
-Record Struct_with_tuple_t (T1 T2 : Type) :=
-mkStruct_with_tuple_t {
-  Struct_with_tuple_p : (T1 * T2);
+Record StructWithTuple_t (T1 T2 : Type) :=
+mkStructWithTuple_t {
+  structWithTuple_p : (T1 * T2);
 }
 .
 
-Arguments mkStruct_with_tuple_t {T1} {T2} _.
-Arguments Struct_with_tuple_p {T1} {T2}.
+Arguments mkStructWithTuple_t {T1} {T2} _.
+Arguments structWithTuple_p {T1} {T2}.
 
 (** [no_nested_borrows::new_tuple1]: forward function *)
-Definition new_tuple1_fwd : result (Struct_with_tuple_t u32 u32) :=
-  Return {| Struct_with_tuple_p := (1%u32, 2%u32) |}
+Definition new_tuple1 : result (StructWithTuple_t u32 u32) :=
+  Return {| structWithTuple_p := (1%u32, 2%u32) |}
 .
 
 (** [no_nested_borrows::new_tuple2]: forward function *)
-Definition new_tuple2_fwd : result (Struct_with_tuple_t i16 i16) :=
-  Return {| Struct_with_tuple_p := (1%i16, 2%i16) |}
+Definition new_tuple2 : result (StructWithTuple_t i16 i16) :=
+  Return {| structWithTuple_p := (1%i16, 2%i16) |}
 .
 
 (** [no_nested_borrows::new_tuple3]: forward function *)
-Definition new_tuple3_fwd : result (Struct_with_tuple_t u64 i64) :=
-  Return {| Struct_with_tuple_p := (1%u64, 2%i64) |}
+Definition new_tuple3 : result (StructWithTuple_t u64 i64) :=
+  Return {| structWithTuple_p := (1%u64, 2%i64) |}
 .
 
 (** [no_nested_borrows::StructWithPair] *)
-Record Struct_with_pair_t (T1 T2 : Type) :=
-mkStruct_with_pair_t {
-  Struct_with_pair_p : Pair_t T1 T2;
+Record StructWithPair_t (T1 T2 : Type) :=
+mkStructWithPair_t {
+  structWithPair_p : Pair_t T1 T2;
 }
 .
 
-Arguments mkStruct_with_pair_t {T1} {T2} _.
-Arguments Struct_with_pair_p {T1} {T2}.
+Arguments mkStructWithPair_t {T1} {T2} _.
+Arguments structWithPair_p {T1} {T2}.
 
 (** [no_nested_borrows::new_pair1]: forward function *)
-Definition new_pair1_fwd : result (Struct_with_pair_t u32 u32) :=
-  Return {| Struct_with_pair_p := {| Pair_x := 1%u32; Pair_y := 2%u32 |} |}
+Definition new_pair1 : result (StructWithPair_t u32 u32) :=
+  Return {| structWithPair_p := {| pair_x := 1%u32; pair_y := 2%u32 |} |}
 .
 
 (** [no_nested_borrows::test_constants]: forward function *)
-Definition test_constants_fwd : result unit :=
-  swt <- new_tuple1_fwd;
-  let (i, _) := swt.(Struct_with_tuple_p) in
+Definition test_constants : result unit :=
+  swt <- new_tuple1;
+  let (i, _) := swt.(structWithTuple_p) in
   if negb (i s= 1%u32)
   then Fail_ Failure
   else (
-    swt0 <- new_tuple2_fwd;
-    let (i0, _) := swt0.(Struct_with_tuple_p) in
+    swt0 <- new_tuple2;
+    let (i0, _) := swt0.(structWithTuple_p) in
     if negb (i0 s= 1%i16)
     then Fail_ Failure
     else (
-      swt1 <- new_tuple3_fwd;
-      let (i1, _) := swt1.(Struct_with_tuple_p) in
+      swt1 <- new_tuple3;
+      let (i1, _) := swt1.(structWithTuple_p) in
       if negb (i1 s= 1%u64)
       then Fail_ Failure
       else (
-        swp <- new_pair1_fwd;
-        if negb (swp.(Struct_with_pair_p).(Pair_x) s= 1%u32)
+        swp <- new_pair1;
+        if negb (swp.(structWithPair_p).(pair_x) s= 1%u32)
         then Fail_ Failure
         else Return tt)))
 .
 
 (** Unit test for [no_nested_borrows::test_constants] *)
-Check (test_constants_fwd )%return.
+Check (test_constants )%return.
 
 (** [no_nested_borrows::test_weird_borrows1]: forward function *)
-Definition test_weird_borrows1_fwd : result unit :=
+Definition test_weird_borrows1 : result unit :=
   Return tt.
 
 (** Unit test for [no_nested_borrows::test_weird_borrows1] *)
-Check (test_weird_borrows1_fwd )%return.
+Check (test_weird_borrows1 )%return.
 
 (** [no_nested_borrows::test_mem_replace]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition test_mem_replace_fwd_back (px : u32) : result u32 :=
-  let y := mem_replace_fwd u32 px 1%u32 in
+Definition test_mem_replace (px : u32) : result u32 :=
+  let y := core_mem_replace u32 px 1%u32 in
   if negb (y s= 0%u32) then Fail_ Failure else Return 2%u32
 .
 
 (** [no_nested_borrows::test_shared_borrow_bool1]: forward function *)
-Definition test_shared_borrow_bool1_fwd (b : bool) : result u32 :=
+Definition test_shared_borrow_bool1 (b : bool) : result u32 :=
   if b then Return 0%u32 else Return 1%u32
 .
 
 (** [no_nested_borrows::test_shared_borrow_bool2]: forward function *)
-Definition test_shared_borrow_bool2_fwd : result u32 :=
+Definition test_shared_borrow_bool2 : result u32 :=
   Return 0%u32.
 
 (** [no_nested_borrows::test_shared_borrow_enum1]: forward function *)
-Definition test_shared_borrow_enum1_fwd (l : List_t u32) : result u32 :=
-  match l with | ListCons i l0 => Return 1%u32 | ListNil => Return 0%u32 end
+Definition test_shared_borrow_enum1 (l : List_t u32) : result u32 :=
+  match l with | List_Cons i l0 => Return 1%u32 | List_Nil => Return 0%u32 end
 .
 
 (** [no_nested_borrows::test_shared_borrow_enum2]: forward function *)
-Definition test_shared_borrow_enum2_fwd : result u32 :=
+Definition test_shared_borrow_enum2 : result u32 :=
   Return 0%u32.
 
 End NoNestedBorrows .
diff --git a/tests/coq/misc/Paper.v b/tests/coq/misc/Paper.v
index 175a523d..d397995b 100644
--- a/tests/coq/misc/Paper.v
+++ b/tests/coq/misc/Paper.v
@@ -10,20 +10,19 @@ Module Paper.
 
 (** [paper::ref_incr]: merged forward/backward function
     (there is a single backward function, and the forward function returns ()) *)
-Definition ref_incr_fwd_back (x : i32) : result i32 :=
+Definition ref_incr (x : i32) : result i32 :=
   i32_add x 1%i32.
 
 (** [paper::test_incr]: forward function *)
-Definition test_incr_fwd : result unit :=
-  x <- ref_incr_fwd_back 0%i32;
-  if negb (x s= 1%i32) then Fail_ Failure else Return tt
+Definition test_incr : result unit :=
+  x <- ref_incr 0%i32; if negb (x s= 1%i32) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [paper::test_incr] *)
-Check (test_incr_fwd )%return.
+Check (test_incr )%return.
 
 (** [paper::choose]: forward function *)
-Definition choose_fwd (T : Type) (b : bool) (x : T) (y : T) : result T :=
+Definition choose (T : Type) (b : bool) (x : T) (y : T) : result T :=
   if b then Return x else Return y
 .
 
@@ -34,8 +33,8 @@ Definition choose_back
 .
 
 (** [paper::test_choose]: forward function *)
-Definition test_choose_fwd : result unit :=
-  z <- choose_fwd i32 true 0%i32 0%i32;
+Definition test_choose : result unit :=
+  z <- choose i32 true 0%i32 0%i32;
   z0 <- i32_add z 1%i32;
   if negb (z0 s= 1%i32)
   then Fail_ Failure
@@ -48,25 +47,25 @@ Definition test_choose_fwd : result unit :=
 .
 
 (** Unit test for [paper::test_choose] *)
-Check (test_choose_fwd )%return.
+Check (test_choose )%return.
 
 (** [paper::List] *)
 Inductive List_t (T : Type) :=
-| ListCons : T -> List_t T -> List_t T
-| ListNil : List_t T
+| List_Cons : T -> List_t T -> List_t T
+| List_Nil : List_t T
 .
 
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons {T} _ _.
+Arguments List_Nil {T}.
 
 (** [paper::list_nth_mut]: forward function *)
-Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
+Fixpoint list_nth_mut (T : Type) (l : List_t T) (i : u32) : result T :=
   match l with
-  | ListCons x tl =>
+  | List_Cons x tl =>
     if i s= 0%u32
     then Return x
-    else (i0 <- u32_sub i 1%u32; list_nth_mut_fwd T tl i0)
-  | ListNil => Fail_ Failure
+    else (i0 <- u32_sub i 1%u32; list_nth_mut T tl i0)
+  | List_Nil => Fail_ Failure
   end
 .
 
@@ -74,44 +73,44 @@ Fixpoint list_nth_mut_fwd (T : Type) (l : List_t T) (i : u32) : result T :=
 Fixpoint list_nth_mut_back
   (T : Type) (l : List_t T) (i : u32) (ret : T) : result (List_t T) :=
   match l with
-  | ListCons x tl =>
+  | List_Cons x tl =>
     if i s= 0%u32
-    then Return (ListCons ret tl)
+    then Return (List_Cons ret tl)
     else (
       i0 <- u32_sub i 1%u32;
       tl0 <- list_nth_mut_back T tl i0 ret;
-      Return (ListCons x tl0))
-  | ListNil => Fail_ Failure
+      Return (List_Cons x tl0))
+  | List_Nil => Fail_ Failure
   end
 .
 
 (** [paper::sum]: forward function *)
-Fixpoint sum_fwd (l : List_t i32) : result i32 :=
+Fixpoint sum (l : List_t i32) : result i32 :=
   match l with
-  | ListCons x tl => i <- sum_fwd tl; i32_add x i
-  | ListNil => Return 0%i32
+  | List_Cons x tl => i <- sum tl; i32_add x i
+  | List_Nil => Return 0%i32
   end
 .
 
 (** [paper::test_nth]: forward function *)
-Definition test_nth_fwd : result unit :=
-  let l := ListNil in
-  let l0 := ListCons 3%i32 l in
-  let l1 := ListCons 2%i32 l0 in
-  x <- list_nth_mut_fwd i32 (ListCons 1%i32 l1) 2%u32;
+Definition test_nth : result unit :=
+  let l := List_Nil in
+  let l0 := List_Cons 3%i32 l in
+  let l1 := List_Cons 2%i32 l0 in
+  x <- list_nth_mut i32 (List_Cons 1%i32 l1) 2%u32;
   x0 <- i32_add x 1%i32;
-  l2 <- list_nth_mut_back i32 (ListCons 1%i32 l1) 2%u32 x0;
-  i <- sum_fwd l2;
+  l2 <- list_nth_mut_back i32 (List_Cons 1%i32 l1) 2%u32 x0;
+  i <- sum l2;
   if negb (i s= 7%i32) then Fail_ Failure else Return tt
 .
 
 (** Unit test for [paper::test_nth] *)
-Check (test_nth_fwd )%return.
+Check (test_nth )%return.
 
 (** [paper::call_choose]: forward function *)
-Definition call_choose_fwd (p : (u32 * u32)) : result u32 :=
+Definition call_choose (p : (u32 * u32)) : result u32 :=
   let (px, py) := p in
-  pz <- choose_fwd u32 true px py;
+  pz <- choose u32 true px py;
   pz0 <- u32_add pz 1%u32;
   p0 <- choose_back u32 true px py pz0;
   let (px0, _) := p0 in
diff --git a/tests/coq/misc/PoloniusList.v b/tests/coq/misc/PoloniusList.v
index 54021bdf..4f804b55 100644
--- a/tests/coq/misc/PoloniusList.v
+++ b/tests/coq/misc/PoloniusList.v
@@ -10,19 +10,19 @@ Module PoloniusList.
 
 (** [polonius_list::List] *)
 Inductive List_t (T : Type) :=
-| ListCons : T -> List_t T -> List_t T
-| ListNil : List_t T
+| List_Cons : T -> List_t T -> List_t T
+| List_Nil : List_t T
 .
 
-Arguments ListCons {T} _ _.
-Arguments ListNil {T}.
+Arguments List_Cons {T} _ _.
+Arguments List_Nil {T}.
 
 (** [polonius_list::get_list_at_x]: forward function *)
-Fixpoint get_list_at_x_fwd (ls : List_t u32) (x : u32) : result (List_t u32) :=
+Fixpoint get_list_at_x (ls : List_t u32) (x : u32) : result (List_t u32) :=
   match ls with
-  | ListCons hd tl =>
-    if hd s= x then Return (ListCons hd tl) else get_list_at_x_fwd tl x
-  | ListNil => Return ListNil
+  | List_Cons hd tl =>
+    if hd s= x then Return (List_Cons hd tl) else get_list_at_x tl x
+  | List_Nil => Return List_Nil
   end
 .
 
@@ -30,11 +30,11 @@ Fixpoint get_list_at_x_fwd (ls : List_t u32) (x : u32) : result (List_t u32) :=
 Fixpoint get_list_at_x_back
   (ls : List_t u32) (x : u32) (ret : List_t u32) : result (List_t u32) :=
   match ls with
-  | ListCons hd tl =>
+  | List_Cons hd tl =>
     if hd s= x
     then Return ret
-    else (tl0 <- get_list_at_x_back tl x ret; Return (ListCons hd tl0))
-  | ListNil => Return ret
+    else (tl0 <- get_list_at_x_back tl x ret; Return (List_Cons hd tl0))
+  | List_Nil => Return ret
   end
 .
 
diff --git a/tests/coq/misc/Primitives.v b/tests/coq/misc/Primitives.v
index 8d6c9c8d..85e38f01 100644
--- a/tests/coq/misc/Primitives.v
+++ b/tests/coq/misc/Primitives.v
@@ -63,13 +63,15 @@ Check (if true then Return (1 + 2) else Fail_ Failure)%global = 3.
 
 (*** Misc *)
 
-
 Definition string := Coq.Strings.String.string.
 Definition char := Coq.Strings.Ascii.ascii.
 Definition char_of_byte := Coq.Strings.Ascii.ascii_of_byte.
 
-Definition mem_replace_fwd (a : Type) (x : a) (y : a) : a := x .
-Definition mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+Definition core_mem_replace (a : Type) (x : a) (y : a) : a := x .
+Definition core_mem_replace_back (a : Type) (x : a) (y : a) : a := y .
+
+Record mut_raw_ptr (T : Type) := { mut_raw_ptr_v : T }.
+Record const_raw_ptr (T : Type) := { const_raw_ptr_v : T }.
 
 (*** Scalars *)
 
@@ -408,12 +410,75 @@ Definition core_i64_max   := i64_max %i64.
 Definition core_i128_max  := i64_max %i128.
 Axiom core_isize_max : isize. (** TODO *)
 
-(*** Range *)
-Record range (T : Type) := mk_range {
-  start: T;
-  end_: T;
+(*** core::ops *)
+
+(* Trait declaration: [core::ops::index::Index] *)
+Record core_ops_index_Index (Self Idx : Type) := mk_core_ops_index_Index {
+  core_ops_index_Index_Output : Type;
+  core_ops_index_Index_index : Self -> Idx -> result core_ops_index_Index_Output;
+}.
+Arguments mk_core_ops_index_Index {_ _}.
+Arguments core_ops_index_Index_Output {_ _}.
+Arguments core_ops_index_Index_index {_ _}.
+
+(* Trait declaration: [core::ops::index::IndexMut] *)
+Record core_ops_index_IndexMut (Self Idx : Type) := mk_core_ops_index_IndexMut {
+  core_ops_index_IndexMut_indexInst : core_ops_index_Index Self Idx;
+  core_ops_index_IndexMut_index_mut : Self -> Idx -> result core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output);
+  core_ops_index_IndexMut_index_mut_back : Self -> Idx -> core_ops_index_IndexMut_indexInst.(core_ops_index_Index_Output) -> result Self;
+}.
+Arguments mk_core_ops_index_IndexMut {_ _}.
+Arguments core_ops_index_IndexMut_indexInst {_ _}.
+Arguments core_ops_index_IndexMut_index_mut {_ _}.
+Arguments core_ops_index_IndexMut_index_mut_back {_ _}.
+
+(* Trait declaration [core::ops::deref::Deref] *)
+Record core_ops_deref_Deref (Self : Type) := mk_core_ops_deref_Deref {
+  core_ops_deref_Deref_target : Type;
+  core_ops_deref_Deref_deref : Self -> result core_ops_deref_Deref_target;
+}.
+Arguments mk_core_ops_deref_Deref {_}.
+Arguments core_ops_deref_Deref_target {_}.
+Arguments core_ops_deref_Deref_deref {_}.
+
+(* Trait declaration [core::ops::deref::DerefMut] *)
+Record core_ops_deref_DerefMut (Self : Type) := mk_core_ops_deref_DerefMut {
+  core_ops_deref_DerefMut_derefInst : core_ops_deref_Deref Self;
+  core_ops_deref_DerefMut_deref_mut : Self -> result core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target);
+  core_ops_deref_DerefMut_deref_mut_back : Self -> core_ops_deref_DerefMut_derefInst.(core_ops_deref_Deref_target) -> result Self;
 }.
-Arguments mk_range {_}.
+Arguments mk_core_ops_deref_DerefMut {_}.
+Arguments core_ops_deref_DerefMut_derefInst {_}.
+Arguments core_ops_deref_DerefMut_deref_mut {_}.
+Arguments core_ops_deref_DerefMut_deref_mut_back {_}.
+
+Record core_ops_range_Range (T : Type) := mk_core_ops_range_Range {
+  core_ops_range_Range_start : T;
+  core_ops_range_Range_end_ : T;
+}.
+Arguments mk_core_ops_range_Range {_}.
+Arguments core_ops_range_Range_start {_}.
+Arguments core_ops_range_Range_end_ {_}.
+
+(*** [alloc] *)
+
+Definition alloc_boxed_Box_deref (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut (T : Type) (x : T) : result T := Return x.
+Definition alloc_boxed_Box_deref_mut_back (T : Type) (_ : T) (x : T) : result T := Return x.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefInst (Self : Type) : core_ops_deref_Deref Self := {|
+  core_ops_deref_Deref_target := Self;
+  core_ops_deref_Deref_deref := alloc_boxed_Box_deref Self;
+|}.
+
+(* Trait instance *)
+Definition alloc_boxed_Box_coreOpsDerefMutInst (Self : Type) : core_ops_deref_DerefMut Self := {|
+  core_ops_deref_DerefMut_derefInst := alloc_boxed_Box_coreOpsDerefInst Self;
+  core_ops_deref_DerefMut_deref_mut := alloc_boxed_Box_deref_mut Self;
+  core_ops_deref_DerefMut_deref_mut_back := alloc_boxed_Box_deref_mut_back Self;
+|}.
+
 
 (*** Arrays *)
 Definition array T (n : usize) := { l: list T | Z.of_nat (length l) = to_Z n}.
@@ -433,51 +498,50 @@ Qed.
 (* TODO: finish the definitions *)
 Axiom mk_array : forall (T : Type) (n : usize) (l : list T), array T n.
 
-Axiom array_index_shared : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_fwd : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
-Axiom array_index_mut_back : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
+(* For initialization *)
+Axiom array_repeat : forall (T : Type) (n : usize) (x : T), array T n.
+
+Axiom array_index_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize), result T.
+Axiom array_update_usize : forall (T : Type) (n : usize) (x : array T n) (i : usize) (nx : T), result (array T n).
 
 (*** Slice *)
 Definition slice T := { l: list T | Z.of_nat (length l) <= usize_max}.
 
 Axiom slice_len : forall (T : Type) (s : slice T), usize.
-Axiom slice_index_shared : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_fwd : forall (T : Type) (x : slice T) (i : usize), result T.
-Axiom slice_index_mut_back : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
+Axiom slice_index_usize : forall (T : Type) (x : slice T) (i : usize), result T.
+Axiom slice_update_usize : forall (T : Type) (x : slice T) (i : usize) (nx : T), result (slice T).
 
 (*** Subslices *)
 
-Axiom array_to_slice_shared : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_fwd : forall (T : Type) (n : usize) (x : array T n), result (slice T).
-Axiom array_to_slice_mut_back : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+Axiom array_to_slice : forall (T : Type) (n : usize) (x : array T n), result (slice T).
+Axiom array_from_slice : forall (T : Type) (n : usize) (x : array T n) (s : slice T), result (array T n).
+
+Axiom array_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize), result (slice T).
+Axiom array_update_subslice: forall (T : Type) (n : usize) (x : array T n) (r : core_ops_range_Range usize) (ns : slice T), result (array T n).
 
-Axiom array_subslice_shared: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_fwd: forall (T : Type) (n : usize) (x : array T n) (r : range usize), result (slice T).
-Axiom array_subslice_mut_back: forall (T : Type) (n : usize) (x : array T n) (r : range usize) (ns : slice T), result (array T n).
-Axiom slice_subslice_shared: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_fwd: forall (T : Type) (x : slice T) (r : range usize), result (slice T).
-Axiom slice_subslice_mut_back: forall (T : Type) (x : slice T) (r : range usize) (ns : slice T), result (slice T).
+Axiom slice_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize), result (slice T).
+Axiom slice_update_subslice: forall (T : Type) (x : slice T) (r : core_ops_range_Range usize) (ns : slice T), result (slice T).
 
 (*** Vectors *)
 
-Definition vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
+Definition alloc_vec_Vec T := { l: list T | Z.of_nat (length l) <= usize_max }.
 
-Definition vec_to_list {T: Type} (v: vec T) : list T := proj1_sig v.
+Definition alloc_vec_Vec_to_list {T: Type} (v: alloc_vec_Vec T) : list T := proj1_sig v.
 
-Definition vec_length {T: Type} (v: vec T) : Z := Z.of_nat (length (vec_to_list v)).
+Definition alloc_vec_Vec_length {T: Type} (v: alloc_vec_Vec T) : Z := Z.of_nat (length (alloc_vec_Vec_to_list v)).
 
-Definition vec_new (T: Type) : vec T := (exist _ [] le_0_usize_max).
+Definition alloc_vec_Vec_new (T: Type) : alloc_vec_Vec T := (exist _ [] le_0_usize_max).
 
-Lemma vec_len_in_usize {T} (v: vec T) : usize_min <= vec_length v <= usize_max.
+Lemma alloc_vec_Vec_len_in_usize {T} (v: alloc_vec_Vec T) : usize_min <= alloc_vec_Vec_length v <= usize_max.
 Proof.
-  unfold vec_length, usize_min.
+  unfold alloc_vec_Vec_length, usize_min.
   split.
   - lia.
   - apply (proj2_sig v).
 Qed.
 
-Definition vec_len (T: Type) (v: vec T) : usize :=
-  exist _ (vec_length v) (vec_len_in_usize v).
+Definition alloc_vec_Vec_len (T: Type) (v: alloc_vec_Vec T) : usize :=
+  exist _ (alloc_vec_Vec_length v) (alloc_vec_Vec_len_in_usize v).
 
 Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
   : list A :=
@@ -488,50 +552,271 @@ Fixpoint list_update {A} (l: list A) (n: nat) (a: A)
     | S m => x :: (list_update t m a)
 end end.
 
-Definition vec_bind {A B} (v: vec A) (f: list A -> result (list B)) : result (vec B) :=
-  l <- f (vec_to_list v) ;
+Definition alloc_vec_Vec_bind {A B} (v: alloc_vec_Vec A) (f: list A -> result (list B)) : result (alloc_vec_Vec B) :=
+  l <- f (alloc_vec_Vec_to_list v) ;
   match sumbool_of_bool (scalar_le_max Usize (Z.of_nat (length l))) with
   | left H => Return (exist _ l (scalar_le_max_valid _ _ H))
   | right _ => Fail_ Failure
   end.
 
 (* The **forward** function shouldn't be used *)
-Definition vec_push_fwd (T: Type) (v: vec T) (x: T) : unit := tt.
+Definition alloc_vec_Vec_push_fwd (T: Type) (v: alloc_vec_Vec T) (x: T) : unit := tt.
 
-Definition vec_push_back (T: Type) (v: vec T) (x: T) : result (vec T) :=
-  vec_bind v (fun l => Return (l ++ [x])).
+Definition alloc_vec_Vec_push (T: Type) (v: alloc_vec_Vec T) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l => Return (l ++ [x])).
 
 (* The **forward** function shouldn't be used *)
-Definition vec_insert_fwd (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
+Definition alloc_vec_Vec_insert_fwd (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result unit :=
+  if to_Z i <? alloc_vec_Vec_length v then Return tt else Fail_ Failure.
 
-Definition vec_insert_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
+Definition alloc_vec_Vec_insert (T: Type) (v: alloc_vec_Vec T) (i: usize) (x: T) : result (alloc_vec_Vec T) :=
+  alloc_vec_Vec_bind v (fun l =>
     if to_Z i <? Z.of_nat (length l)
     then Return (list_update l (usize_to_nat i) x)
     else Fail_ Failure).
 
-(* The **backward** function shouldn't be used *)
-Definition vec_index_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
-  end.
-
-Definition vec_index_back (T: Type) (v: vec T) (i: usize) (x: T) : result unit :=
-  if to_Z i <? vec_length v then Return tt else Fail_ Failure.
-
-(* The **backward** function shouldn't be used *)
-Definition vec_index_mut_fwd (T: Type) (v: vec T) (i: usize) : result T :=
-  match nth_error (vec_to_list v) (usize_to_nat i) with
-  | Some n => Return n
-  | None   => Fail_ Failure
+(* Helper *)
+Axiom alloc_vec_Vec_index_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result T.
+
+(* Helper *)
+Axiom alloc_vec_Vec_update_usize : forall {T : Type} (v : alloc_vec_Vec T) (i : usize) (x : T), result (alloc_vec_Vec T).
+
+(* Trait declaration: [core::slice::index::private_slice_index::Sealed] *)
+Definition core_slice_index_private_slice_index_Sealed (self : Type) := unit.
+
+(* Trait declaration: [core::slice::index::SliceIndex] *)
+Record core_slice_index_SliceIndex (Self T : Type) := mk_core_slice_index_SliceIndex {
+  core_slice_index_SliceIndex_sealedInst : core_slice_index_private_slice_index_Sealed Self;
+  core_slice_index_SliceIndex_Output : Type;
+  core_slice_index_SliceIndex_get : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut : Self -> T -> result (option core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_mut_back : Self -> T -> option core_slice_index_SliceIndex_Output -> result T;
+  core_slice_index_SliceIndex_get_unchecked : Self -> const_raw_ptr T -> result (const_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_get_unchecked_mut : Self -> mut_raw_ptr T -> result (mut_raw_ptr core_slice_index_SliceIndex_Output);
+  core_slice_index_SliceIndex_index : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut : Self -> T -> result core_slice_index_SliceIndex_Output;
+  core_slice_index_SliceIndex_index_mut_back : Self -> T -> core_slice_index_SliceIndex_Output -> result T;
+}.
+Arguments mk_core_slice_index_SliceIndex {_ _}.
+Arguments core_slice_index_SliceIndex_sealedInst {_ _}.
+Arguments core_slice_index_SliceIndex_Output {_ _}.
+Arguments core_slice_index_SliceIndex_get {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut {_ _}.
+Arguments core_slice_index_SliceIndex_get_mut_back {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked {_ _}.
+Arguments core_slice_index_SliceIndex_get_unchecked_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut {_ _}.
+Arguments core_slice_index_SliceIndex_index_mut_back {_ _}.
+
+(* [core::slice::index::[T]::index]: forward function *)
+Definition core_slice_index_Slice_index
+  (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (s : slice T) (i : Idx) : result inst.(core_slice_index_SliceIndex_Output) :=
+  x <- inst.(core_slice_index_SliceIndex_get) i s;
+  match x with
+  | None => Fail_ Failure
+  | Some x => Return x
   end.
 
-Definition vec_index_mut_back (T: Type) (v: vec T) (i: usize) (x: T) : result (vec T) :=
-  vec_bind v (fun l =>
-    if to_Z i <? Z.of_nat (length l)
-    then Return (list_update l (usize_to_nat i) x)
-    else Fail_ Failure).
+(* [core::slice::index::Range:::get]: forward function *)
+Axiom core_slice_index_Range_get : forall (T : Type) (i : core_ops_range_Range usize) (s : slice T), result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: forward function *)
+Axiom core_slice_index_Range_get_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (option (slice T)).
+
+(* [core::slice::index::Range::get_mut]: backward function 0 *)
+Axiom core_slice_index_Range_get_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> option (slice T) -> result (slice T).
+
+(* [core::slice::index::Range::get_unchecked]: forward function *)
+Definition core_slice_index_Range_get_unchecked
+  (T : Type) :
+  core_ops_range_Range usize -> const_raw_ptr (slice T) -> result (const_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+     sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::get_unchecked_mut]: forward function *)
+Definition core_slice_index_Range_get_unchecked_mut
+  (T : Type) :
+  core_ops_range_Range usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr (slice T)) :=
+  (* Don't know what the model should be - for now we always fail to make
+    sure code which uses it fails *)
+  fun _ _ => Fail_ Failure.
+
+(* [core::slice::index::Range::index]: forward function *)
+Axiom core_slice_index_Range_index :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: forward function *)
+Axiom core_slice_index_Range_index_mut :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> result (slice T).
+
+(* [core::slice::index::Range::index_mut]: backward function 0 *)
+Axiom core_slice_index_Range_index_mut_back :
+  forall (T : Type), core_ops_range_Range usize -> slice T -> slice T -> result (slice T).
+
+(* [core::slice::index::[T]::index_mut]: forward function *)
+Axiom core_slice_index_Slice_index_mut :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> result inst.(core_slice_index_SliceIndex_Output).
+
+(* [core::slice::index::[T]::index_mut]: backward function 0 *)
+Axiom core_slice_index_Slice_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T)),
+  slice T -> Idx -> inst.(core_slice_index_SliceIndex_Output) -> result (slice T).
+
+(* [core::array::[T; N]::index]: forward function *)
+Axiom core_array_Array_index :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_Index (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: forward function *)
+Axiom core_array_Array_index_mut :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx), result inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output).
+
+(* [core::array::[T; N]::index_mut]: backward function 0 *)
+Axiom core_array_Array_index_mut_back :
+  forall (T Idx : Type) (N : usize) (inst : core_ops_index_IndexMut (slice T) Idx)
+  (a : array T N) (i : Idx) (x : inst.(core_ops_index_IndexMut_indexInst).(core_ops_index_Index_Output)), result (array T N).
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (slice T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := core_slice_index_Slice_index T Idx inst;
+|}.
+
+(* Trait implementation: [core::slice::index::private_slice_index::Range] *)
+Definition core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed (core_ops_range_Range usize) := tt.
+
+(* Trait implementation: [core::slice::index::Range] *)
+Definition core_slice_index_Range_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex (core_ops_range_Range usize) (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_Range_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := slice T;
+  core_slice_index_SliceIndex_get := core_slice_index_Range_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_Range_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_Range_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_Range_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_Range_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_Range_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_Range_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_Range_index_mut_back T;
+|}.
+
+(* Trait implementation: [core::slice::index::[T]] *)
+Definition core_slice_index_Slice_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (slice T) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_slice_index_Slice_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := core_slice_index_Slice_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := core_slice_index_Slice_index_mut_back T Idx inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_Index (slice T) Idx) :
+  core_ops_index_Index (array T N) Idx := {|
+  core_ops_index_Index_Output := inst.(core_ops_index_Index_Output);
+  core_ops_index_Index_index := core_array_Array_index T Idx N inst;
+|}.
+
+(* Trait implementation: [core::array::[T; N]] *)
+Definition core_array_Array_coreopsindexIndexMutInst (T Idx : Type) (N : usize)
+  (inst : core_ops_index_IndexMut (slice T) Idx) :
+  core_ops_index_IndexMut (array T N) Idx := {|
+  core_ops_index_IndexMut_indexInst := core_array_Array_coreopsindexIndexInst T Idx N inst.(core_ops_index_IndexMut_indexInst);
+  core_ops_index_IndexMut_index_mut := core_array_Array_index_mut T Idx N inst;
+  core_ops_index_IndexMut_index_mut_back := core_array_Array_index_mut_back T Idx N inst;
+|}.
+
+(* [core::slice::index::usize::get]: forward function *)
+Axiom core_slice_index_usize_get : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: forward function *)
+Axiom core_slice_index_usize_get_mut : forall (T : Type), usize -> slice T -> result (option T).
+
+(* [core::slice::index::usize::get_mut]: backward function 0 *)
+Axiom core_slice_index_usize_get_mut_back :
+  forall (T : Type), usize -> slice T -> option T -> result (slice T).
+
+(* [core::slice::index::usize::get_unchecked]: forward function *)
+Axiom core_slice_index_usize_get_unchecked :
+  forall (T : Type), usize -> const_raw_ptr (slice T) -> result (const_raw_ptr T).
+
+(* [core::slice::index::usize::get_unchecked_mut]: forward function *)
+Axiom core_slice_index_usize_get_unchecked_mut :
+  forall (T : Type), usize -> mut_raw_ptr (slice T) -> result (mut_raw_ptr T).
+
+(* [core::slice::index::usize::index]: forward function *)
+Axiom core_slice_index_usize_index : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: forward function *)
+Axiom core_slice_index_usize_index_mut : forall (T : Type), usize -> slice T -> result T.
+
+(* [core::slice::index::usize::index_mut]: backward function 0 *)
+Axiom core_slice_index_usize_index_mut_back :
+  forall (T : Type), usize -> slice T -> T -> result (slice T).
+
+(* Trait implementation: [core::slice::index::private_slice_index::usize] *)
+Definition core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst
+  : core_slice_index_private_slice_index_Sealed usize := tt.
+
+(* Trait implementation: [core::slice::index::usize] *)
+Definition core_slice_index_usize_coresliceindexSliceIndexInst (T : Type) :
+  core_slice_index_SliceIndex usize (slice T) := {|
+  core_slice_index_SliceIndex_sealedInst := core_slice_index_private_slice_index_usize_coresliceindexprivate_slice_indexSealedInst;
+  core_slice_index_SliceIndex_Output := T;
+  core_slice_index_SliceIndex_get := core_slice_index_usize_get T;
+  core_slice_index_SliceIndex_get_mut := core_slice_index_usize_get_mut T;
+  core_slice_index_SliceIndex_get_mut_back := core_slice_index_usize_get_mut_back T;
+  core_slice_index_SliceIndex_get_unchecked := core_slice_index_usize_get_unchecked T;
+  core_slice_index_SliceIndex_get_unchecked_mut := core_slice_index_usize_get_unchecked_mut T;
+  core_slice_index_SliceIndex_index := core_slice_index_usize_index T;
+  core_slice_index_SliceIndex_index_mut := core_slice_index_usize_index_mut T;
+  core_slice_index_SliceIndex_index_mut_back := core_slice_index_usize_index_mut_back T;
+|}.
+
+(* [alloc::vec::Vec::index]: forward function *)
+Axiom alloc_vec_Vec_index : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: forward function *)
+Axiom alloc_vec_Vec_index_mut : forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx), result inst.(core_slice_index_SliceIndex_Output).
+
+(* [alloc::vec::Vec::index_mut]: backward function 0 *)
+Axiom alloc_vec_Vec_index_mut_back :
+  forall (T Idx : Type) (inst : core_slice_index_SliceIndex Idx (slice T))
+  (Self : alloc_vec_Vec T) (i : Idx) (x : inst.(core_slice_index_SliceIndex_Output)), result (alloc_vec_Vec T).
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_Index (alloc_vec_Vec T) Idx := {|
+  core_ops_index_Index_Output := inst.(core_slice_index_SliceIndex_Output);
+  core_ops_index_Index_index := alloc_vec_Vec_index T Idx inst;
+|}.
+
+(* Trait implementation: [alloc::vec::Vec] *)
+Definition alloc_vec_Vec_coreopsindexIndexMutInst (T Idx : Type)
+  (inst : core_slice_index_SliceIndex Idx (slice T)) :
+  core_ops_index_IndexMut (alloc_vec_Vec T) Idx := {|
+  core_ops_index_IndexMut_indexInst := alloc_vec_Vec_coreopsindexIndexInst T Idx inst;
+  core_ops_index_IndexMut_index_mut := alloc_vec_Vec_index_mut T Idx inst;
+  core_ops_index_IndexMut_index_mut_back := alloc_vec_Vec_index_mut_back T Idx inst;
+|}.
+
+(*** Theorems *)
+
+Axiom alloc_vec_Vec_index_mut_back_eq : forall {a : Type} (v : alloc_vec_Vec a) (i : usize) (x : a),
+  alloc_vec_Vec_index_mut_back a usize (core_slice_index_usize_coresliceindexSliceIndexInst a) v i x =
+    alloc_vec_Vec_update_usize v i x.
 
 End Primitives.