Improve the generated comments

1 files changed, 148 insertions, 152 deletions

diff --git a/tests/lean/Loops/Funs.lean b/tests/lean/Loops/Funs.lean
index 6e6eef3b..8cac7ac0 100644
--- a/tests/lean/Loops/Funs.lean
+++ b/tests/lean/Loops/Funs.lean
@@ -5,82 +5,83 @@ import Loops.Types
 open Primitives
 namespace loops
 
-/- [loops::sum] -/
-divergent def sum_loop_fwd (max : U32) (i : U32) (s : U32) : Result U32 :=
+/- [loops::sum]: loop 0: forward function -/
+divergent def sum_loop (max : U32) (i : U32) (s : U32) : Result U32 :=
   if i < max
   then
     do
       let s0 ← s + i
       let i0 ← i + (U32.ofInt 1 (by intlit))
-      sum_loop_fwd max i0 s0
+      sum_loop max i0 s0
   else s * (U32.ofInt 2 (by intlit))
 
-/- [loops::sum] -/
-def sum_fwd (max : U32) : Result U32 :=
-  sum_loop_fwd max (U32.ofInt 0 (by intlit)) (U32.ofInt 0 (by intlit))
+/- [loops::sum]: forward function -/
+def sum (max : U32) : Result U32 :=
+  sum_loop max (U32.ofInt 0 (by intlit)) (U32.ofInt 0 (by intlit))
 
-/- [loops::sum_with_mut_borrows] -/
-divergent def sum_with_mut_borrows_loop_fwd
+/- [loops::sum_with_mut_borrows]: loop 0: forward function -/
+divergent def sum_with_mut_borrows_loop
   (max : U32) (mi : U32) (ms : U32) : Result U32 :=
   if mi < max
   then
     do
       let ms0 ← ms + mi
       let mi0 ← mi + (U32.ofInt 1 (by intlit))
-      sum_with_mut_borrows_loop_fwd max mi0 ms0
+      sum_with_mut_borrows_loop max mi0 ms0
   else ms * (U32.ofInt 2 (by intlit))
 
-/- [loops::sum_with_mut_borrows] -/
-def sum_with_mut_borrows_fwd (max : U32) : Result U32 :=
-  sum_with_mut_borrows_loop_fwd max (U32.ofInt 0 (by intlit))
+/- [loops::sum_with_mut_borrows]: forward function -/
+def sum_with_mut_borrows (max : U32) : Result U32 :=
+  sum_with_mut_borrows_loop max (U32.ofInt 0 (by intlit))
     (U32.ofInt 0 (by intlit))
 
-/- [loops::sum_with_shared_borrows] -/
-divergent def sum_with_shared_borrows_loop_fwd
+/- [loops::sum_with_shared_borrows]: loop 0: forward function -/
+divergent def sum_with_shared_borrows_loop
   (max : U32) (i : U32) (s : U32) : Result U32 :=
   if i < max
   then
     do
       let i0 ← i + (U32.ofInt 1 (by intlit))
       let s0 ← s + i0
-      sum_with_shared_borrows_loop_fwd max i0 s0
+      sum_with_shared_borrows_loop max i0 s0
   else s * (U32.ofInt 2 (by intlit))
 
-/- [loops::sum_with_shared_borrows] -/
-def sum_with_shared_borrows_fwd (max : U32) : Result U32 :=
-  sum_with_shared_borrows_loop_fwd max (U32.ofInt 0 (by intlit))
+/- [loops::sum_with_shared_borrows]: forward function -/
+def sum_with_shared_borrows (max : U32) : Result U32 :=
+  sum_with_shared_borrows_loop max (U32.ofInt 0 (by intlit))
     (U32.ofInt 0 (by intlit))
 
-/- [loops::clear] -/
-divergent def clear_loop_fwd_back
-  (v : Vec U32) (i : Usize) : Result (Vec U32) :=
+/- [loops::clear]: loop 0: merged forward/backward function
+   (there is a single backward function, and the forward function returns ()) -/
+divergent def clear_loop (v : Vec U32) (i : Usize) : Result (Vec U32) :=
   let i0 := Vec.len U32 v
   if i < i0
   then
     do
       let i1 ← i + (Usize.ofInt 1 (by intlit))
       let v0 ← Vec.index_mut_back U32 v i (U32.ofInt 0 (by intlit))
-      clear_loop_fwd_back v0 i1
+      clear_loop v0 i1
   else Result.ret v
 
-/- [loops::clear] -/
-def clear_fwd_back (v : Vec U32) : Result (Vec U32) :=
-  clear_loop_fwd_back v (Usize.ofInt 0 (by intlit))
+/- [loops::clear]: merged forward/backward function
+   (there is a single backward function, and the forward function returns ()) -/
+def clear (v : Vec U32) : Result (Vec U32) :=
+  clear_loop v (Usize.ofInt 0 (by intlit))
 
-/- [loops::list_mem] -/
-divergent def list_mem_loop_fwd (x : U32) (ls : List U32) : Result Bool :=
+/- [loops::list_mem]: loop 0: forward function -/
+divergent def list_mem_loop (x : U32) (ls : List U32) : Result Bool :=
   match ls with
   | List.Cons y tl => if y = x
                       then Result.ret true
-                      else list_mem_loop_fwd x tl
+                      else list_mem_loop x tl
   | List.Nil => Result.ret false
 
-/- [loops::list_mem] -/
-def list_mem_fwd (x : U32) (ls : List U32) : Result Bool :=
-  list_mem_loop_fwd x ls
+/- [loops::list_mem]: forward function -/
+def list_mem (x : U32) (ls : List U32) : Result Bool :=
+  list_mem_loop x ls
 
-/- [loops::list_nth_mut_loop] -/
-divergent def list_nth_mut_loop_loop_fwd
+/- [loops::list_nth_mut_loop]: loop 0: forward function -/
+divergent def list_nth_mut_loop_loop
   (T : Type) (ls : List T) (i : U32) : Result T :=
   match ls with
   | List.Cons x tl =>
@@ -89,14 +90,14 @@ divergent def list_nth_mut_loop_loop_fwd
     else
       do
         let i0 ← i - (U32.ofInt 1 (by intlit))
-        list_nth_mut_loop_loop_fwd T tl i0
+        list_nth_mut_loop_loop T tl i0
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop] -/
-def list_nth_mut_loop_fwd (T : Type) (ls : List T) (i : U32) : Result T :=
-  list_nth_mut_loop_loop_fwd T ls i
+/- [loops::list_nth_mut_loop]: forward function -/
+def list_nth_mut_loop (T : Type) (ls : List T) (i : U32) : Result T :=
+  list_nth_mut_loop_loop T ls i
 
-/- [loops::list_nth_mut_loop] -/
+/- [loops::list_nth_mut_loop]: loop 0: backward function 0 -/
 divergent def list_nth_mut_loop_loop_back
   (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
   match ls with
@@ -110,13 +111,13 @@ divergent def list_nth_mut_loop_loop_back
         Result.ret (List.Cons x tl0)
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop] -/
+/- [loops::list_nth_mut_loop]: backward function 0 -/
 def list_nth_mut_loop_back
   (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
   list_nth_mut_loop_loop_back T ls i ret0
 
-/- [loops::list_nth_shared_loop] -/
-divergent def list_nth_shared_loop_loop_fwd
+/- [loops::list_nth_shared_loop]: loop 0: forward function -/
+divergent def list_nth_shared_loop_loop
   (T : Type) (ls : List T) (i : U32) : Result T :=
   match ls with
   | List.Cons x tl =>
@@ -125,30 +126,28 @@ divergent def list_nth_shared_loop_loop_fwd
     else
       do
         let i0 ← i - (U32.ofInt 1 (by intlit))
-        list_nth_shared_loop_loop_fwd T tl i0
+        list_nth_shared_loop_loop T tl i0
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_loop] -/
-def list_nth_shared_loop_fwd (T : Type) (ls : List T) (i : U32) : Result T :=
-  list_nth_shared_loop_loop_fwd T ls i
+/- [loops::list_nth_shared_loop]: forward function -/
+def list_nth_shared_loop (T : Type) (ls : List T) (i : U32) : Result T :=
+  list_nth_shared_loop_loop T ls i
 
-/- [loops::get_elem_mut] -/
-divergent def get_elem_mut_loop_fwd
-  (x : Usize) (ls : List Usize) : Result Usize :=
+/- [loops::get_elem_mut]: loop 0: forward function -/
+divergent def get_elem_mut_loop (x : Usize) (ls : List Usize) : Result Usize :=
   match ls with
-  | List.Cons y tl =>
-    if y = x
-    then Result.ret y
-    else get_elem_mut_loop_fwd x tl
+  | List.Cons y tl => if y = x
+                      then Result.ret y
+                      else get_elem_mut_loop x tl
   | List.Nil => Result.fail Error.panic
 
-/- [loops::get_elem_mut] -/
-def get_elem_mut_fwd (slots : Vec (List Usize)) (x : Usize) : Result Usize :=
+/- [loops::get_elem_mut]: forward function -/
+def get_elem_mut (slots : Vec (List Usize)) (x : Usize) : Result Usize :=
   do
     let l ← Vec.index_mut (List Usize) slots (Usize.ofInt 0 (by intlit))
-    get_elem_mut_loop_fwd x l
+    get_elem_mut_loop x l
 
-/- [loops::get_elem_mut] -/
+/- [loops::get_elem_mut]: loop 0: backward function 0 -/
 divergent def get_elem_mut_loop_back
   (x : Usize) (ls : List Usize) (ret0 : Usize) : Result (List Usize) :=
   match ls with
@@ -161,7 +160,7 @@ divergent def get_elem_mut_loop_back
         Result.ret (List.Cons y tl0)
   | List.Nil => Result.fail Error.panic
 
-/- [loops::get_elem_mut] -/
+/- [loops::get_elem_mut]: backward function 0 -/
 def get_elem_mut_back
   (slots : Vec (List Usize)) (x : Usize) (ret0 : Usize) :
   Result (Vec (List Usize))
@@ -171,37 +170,35 @@ def get_elem_mut_back
     let l0 ← get_elem_mut_loop_back x l ret0
     Vec.index_mut_back (List Usize) slots (Usize.ofInt 0 (by intlit)) l0
 
-/- [loops::get_elem_shared] -/
-divergent def get_elem_shared_loop_fwd
+/- [loops::get_elem_shared]: loop 0: forward function -/
+divergent def get_elem_shared_loop
   (x : Usize) (ls : List Usize) : Result Usize :=
   match ls with
-  | List.Cons y tl =>
-    if y = x
-    then Result.ret y
-    else get_elem_shared_loop_fwd x tl
+  | List.Cons y tl => if y = x
+                      then Result.ret y
+                      else get_elem_shared_loop x tl
   | List.Nil => Result.fail Error.panic
 
-/- [loops::get_elem_shared] -/
-def get_elem_shared_fwd
-  (slots : Vec (List Usize)) (x : Usize) : Result Usize :=
+/- [loops::get_elem_shared]: forward function -/
+def get_elem_shared (slots : Vec (List Usize)) (x : Usize) : Result Usize :=
   do
     let l ← Vec.index (List Usize) slots (Usize.ofInt 0 (by intlit))
-    get_elem_shared_loop_fwd x l
+    get_elem_shared_loop x l
 
-/- [loops::id_mut] -/
-def id_mut_fwd (T : Type) (ls : List T) : Result (List T) :=
+/- [loops::id_mut]: forward function -/
+def id_mut (T : Type) (ls : List T) : Result (List T) :=
   Result.ret ls
 
-/- [loops::id_mut] -/
+/- [loops::id_mut]: backward function 0 -/
 def id_mut_back (T : Type) (ls : List T) (ret0 : List T) : Result (List T) :=
   Result.ret ret0
 
-/- [loops::id_shared] -/
-def id_shared_fwd (T : Type) (ls : List T) : Result (List T) :=
+/- [loops::id_shared]: forward function -/
+def id_shared (T : Type) (ls : List T) : Result (List T) :=
   Result.ret ls
 
-/- [loops::list_nth_mut_loop_with_id] -/
-divergent def list_nth_mut_loop_with_id_loop_fwd
+/- [loops::list_nth_mut_loop_with_id]: loop 0: forward function -/
+divergent def list_nth_mut_loop_with_id_loop
   (T : Type) (i : U32) (ls : List T) : Result T :=
   match ls with
   | List.Cons x tl =>
@@ -210,17 +207,16 @@ divergent def list_nth_mut_loop_with_id_loop_fwd
     else
       do
         let i0 ← i - (U32.ofInt 1 (by intlit))
-        list_nth_mut_loop_with_id_loop_fwd T i0 tl
+        list_nth_mut_loop_with_id_loop T i0 tl
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop_with_id] -/
-def list_nth_mut_loop_with_id_fwd
-  (T : Type) (ls : List T) (i : U32) : Result T :=
+/- [loops::list_nth_mut_loop_with_id]: forward function -/
+def list_nth_mut_loop_with_id (T : Type) (ls : List T) (i : U32) : Result T :=
   do
-    let ls0 ← id_mut_fwd T ls
-    list_nth_mut_loop_with_id_loop_fwd T i ls0
+    let ls0 ← id_mut T ls
+    list_nth_mut_loop_with_id_loop T i ls0
 
-/- [loops::list_nth_mut_loop_with_id] -/
+/- [loops::list_nth_mut_loop_with_id]: loop 0: backward function 0 -/
 divergent def list_nth_mut_loop_with_id_loop_back
   (T : Type) (i : U32) (ls : List T) (ret0 : T) : Result (List T) :=
   match ls with
@@ -234,16 +230,16 @@ divergent def list_nth_mut_loop_with_id_loop_back
         Result.ret (List.Cons x tl0)
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop_with_id] -/
+/- [loops::list_nth_mut_loop_with_id]: backward function 0 -/
 def list_nth_mut_loop_with_id_back
   (T : Type) (ls : List T) (i : U32) (ret0 : T) : Result (List T) :=
   do
-    let ls0 ← id_mut_fwd T ls
+    let ls0 ← id_mut T ls
     let l ← list_nth_mut_loop_with_id_loop_back T i ls0 ret0
     id_mut_back T ls l
 
-/- [loops::list_nth_shared_loop_with_id] -/
-divergent def list_nth_shared_loop_with_id_loop_fwd
+/- [loops::list_nth_shared_loop_with_id]: loop 0: forward function -/
+divergent def list_nth_shared_loop_with_id_loop
   (T : Type) (i : U32) (ls : List T) : Result T :=
   match ls with
   | List.Cons x tl =>
@@ -252,18 +248,18 @@ divergent def list_nth_shared_loop_with_id_loop_fwd
     else
       do
         let i0 ← i - (U32.ofInt 1 (by intlit))
-        list_nth_shared_loop_with_id_loop_fwd T i0 tl
+        list_nth_shared_loop_with_id_loop T i0 tl
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_loop_with_id] -/
-def list_nth_shared_loop_with_id_fwd
+/- [loops::list_nth_shared_loop_with_id]: forward function -/
+def list_nth_shared_loop_with_id
   (T : Type) (ls : List T) (i : U32) : Result T :=
   do
-    let ls0 ← id_shared_fwd T ls
-    list_nth_shared_loop_with_id_loop_fwd T i ls0
+    let ls0 ← id_shared T ls
+    list_nth_shared_loop_with_id_loop T i ls0
 
-/- [loops::list_nth_mut_loop_pair] -/
-divergent def list_nth_mut_loop_pair_loop_fwd
+/- [loops::list_nth_mut_loop_pair]: loop 0: forward function -/
+divergent def list_nth_mut_loop_pair_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -274,16 +270,16 @@ divergent def list_nth_mut_loop_pair_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_mut_loop_pair_loop_fwd T tl0 tl1 i0
+          list_nth_mut_loop_pair_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop_pair] -/
-def list_nth_mut_loop_pair_fwd
+/- [loops::list_nth_mut_loop_pair]: forward function -/
+def list_nth_mut_loop_pair
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_mut_loop_pair_loop_fwd T ls0 ls1 i
+  list_nth_mut_loop_pair_loop T ls0 ls1 i
 
-/- [loops::list_nth_mut_loop_pair] -/
+/- [loops::list_nth_mut_loop_pair]: loop 0: backward function 0 -/
 divergent def list_nth_mut_loop_pair_loop_back'a
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
@@ -302,14 +298,14 @@ divergent def list_nth_mut_loop_pair_loop_back'a
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop_pair] -/
+/- [loops::list_nth_mut_loop_pair]: backward function 0 -/
 def list_nth_mut_loop_pair_back'a
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
   :=
   list_nth_mut_loop_pair_loop_back'a T ls0 ls1 i ret0
 
-/- [loops::list_nth_mut_loop_pair] -/
+/- [loops::list_nth_mut_loop_pair]: loop 0: backward function 1 -/
 divergent def list_nth_mut_loop_pair_loop_back'b
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
@@ -328,15 +324,15 @@ divergent def list_nth_mut_loop_pair_loop_back'b
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop_pair] -/
+/- [loops::list_nth_mut_loop_pair]: backward function 1 -/
 def list_nth_mut_loop_pair_back'b
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
   :=
   list_nth_mut_loop_pair_loop_back'b T ls0 ls1 i ret0
 
-/- [loops::list_nth_shared_loop_pair] -/
-divergent def list_nth_shared_loop_pair_loop_fwd
+/- [loops::list_nth_shared_loop_pair]: loop 0: forward function -/
+divergent def list_nth_shared_loop_pair_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -347,17 +343,17 @@ divergent def list_nth_shared_loop_pair_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_shared_loop_pair_loop_fwd T tl0 tl1 i0
+          list_nth_shared_loop_pair_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_loop_pair] -/
-def list_nth_shared_loop_pair_fwd
+/- [loops::list_nth_shared_loop_pair]: forward function -/
+def list_nth_shared_loop_pair
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_shared_loop_pair_loop_fwd T ls0 ls1 i
+  list_nth_shared_loop_pair_loop T ls0 ls1 i
 
-/- [loops::list_nth_mut_loop_pair_merge] -/
-divergent def list_nth_mut_loop_pair_merge_loop_fwd
+/- [loops::list_nth_mut_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_mut_loop_pair_merge_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -368,16 +364,16 @@ divergent def list_nth_mut_loop_pair_merge_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_mut_loop_pair_merge_loop_fwd T tl0 tl1 i0
+          list_nth_mut_loop_pair_merge_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop_pair_merge] -/
-def list_nth_mut_loop_pair_merge_fwd
+/- [loops::list_nth_mut_loop_pair_merge]: forward function -/
+def list_nth_mut_loop_pair_merge
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_mut_loop_pair_merge_loop_fwd T ls0 ls1 i
+  list_nth_mut_loop_pair_merge_loop T ls0 ls1 i
 
-/- [loops::list_nth_mut_loop_pair_merge] -/
+/- [loops::list_nth_mut_loop_pair_merge]: loop 0: backward function 0 -/
 divergent def list_nth_mut_loop_pair_merge_loop_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : (T × T)) :
   Result ((List T) × (List T))
@@ -398,15 +394,15 @@ divergent def list_nth_mut_loop_pair_merge_loop_back
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_loop_pair_merge] -/
+/- [loops::list_nth_mut_loop_pair_merge]: backward function 0 -/
 def list_nth_mut_loop_pair_merge_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : (T × T)) :
   Result ((List T) × (List T))
   :=
   list_nth_mut_loop_pair_merge_loop_back T ls0 ls1 i ret0
 
-/- [loops::list_nth_shared_loop_pair_merge] -/
-divergent def list_nth_shared_loop_pair_merge_loop_fwd
+/- [loops::list_nth_shared_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_shared_loop_pair_merge_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -417,17 +413,17 @@ divergent def list_nth_shared_loop_pair_merge_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_shared_loop_pair_merge_loop_fwd T tl0 tl1 i0
+          list_nth_shared_loop_pair_merge_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_loop_pair_merge] -/
-def list_nth_shared_loop_pair_merge_fwd
+/- [loops::list_nth_shared_loop_pair_merge]: forward function -/
+def list_nth_shared_loop_pair_merge
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_shared_loop_pair_merge_loop_fwd T ls0 ls1 i
+  list_nth_shared_loop_pair_merge_loop T ls0 ls1 i
 
-/- [loops::list_nth_mut_shared_loop_pair] -/
-divergent def list_nth_mut_shared_loop_pair_loop_fwd
+/- [loops::list_nth_mut_shared_loop_pair]: loop 0: forward function -/
+divergent def list_nth_mut_shared_loop_pair_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -438,16 +434,16 @@ divergent def list_nth_mut_shared_loop_pair_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_mut_shared_loop_pair_loop_fwd T tl0 tl1 i0
+          list_nth_mut_shared_loop_pair_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_shared_loop_pair] -/
-def list_nth_mut_shared_loop_pair_fwd
+/- [loops::list_nth_mut_shared_loop_pair]: forward function -/
+def list_nth_mut_shared_loop_pair
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_mut_shared_loop_pair_loop_fwd T ls0 ls1 i
+  list_nth_mut_shared_loop_pair_loop T ls0 ls1 i
 
-/- [loops::list_nth_mut_shared_loop_pair] -/
+/- [loops::list_nth_mut_shared_loop_pair]: loop 0: backward function 0 -/
 divergent def list_nth_mut_shared_loop_pair_loop_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
@@ -467,15 +463,15 @@ divergent def list_nth_mut_shared_loop_pair_loop_back
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_shared_loop_pair] -/
+/- [loops::list_nth_mut_shared_loop_pair]: backward function 0 -/
 def list_nth_mut_shared_loop_pair_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
   :=
   list_nth_mut_shared_loop_pair_loop_back T ls0 ls1 i ret0
 
-/- [loops::list_nth_mut_shared_loop_pair_merge] -/
-divergent def list_nth_mut_shared_loop_pair_merge_loop_fwd
+/- [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_mut_shared_loop_pair_merge_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -486,16 +482,16 @@ divergent def list_nth_mut_shared_loop_pair_merge_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_mut_shared_loop_pair_merge_loop_fwd T tl0 tl1 i0
+          list_nth_mut_shared_loop_pair_merge_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_shared_loop_pair_merge] -/
-def list_nth_mut_shared_loop_pair_merge_fwd
+/- [loops::list_nth_mut_shared_loop_pair_merge]: forward function -/
+def list_nth_mut_shared_loop_pair_merge
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_mut_shared_loop_pair_merge_loop_fwd T ls0 ls1 i
+  list_nth_mut_shared_loop_pair_merge_loop T ls0 ls1 i
 
-/- [loops::list_nth_mut_shared_loop_pair_merge] -/
+/- [loops::list_nth_mut_shared_loop_pair_merge]: loop 0: backward function 0 -/
 divergent def list_nth_mut_shared_loop_pair_merge_loop_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
@@ -515,15 +511,15 @@ divergent def list_nth_mut_shared_loop_pair_merge_loop_back
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_mut_shared_loop_pair_merge] -/
+/- [loops::list_nth_mut_shared_loop_pair_merge]: backward function 0 -/
 def list_nth_mut_shared_loop_pair_merge_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
   :=
   list_nth_mut_shared_loop_pair_merge_loop_back T ls0 ls1 i ret0
 
-/- [loops::list_nth_shared_mut_loop_pair] -/
-divergent def list_nth_shared_mut_loop_pair_loop_fwd
+/- [loops::list_nth_shared_mut_loop_pair]: loop 0: forward function -/
+divergent def list_nth_shared_mut_loop_pair_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -534,16 +530,16 @@ divergent def list_nth_shared_mut_loop_pair_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_shared_mut_loop_pair_loop_fwd T tl0 tl1 i0
+          list_nth_shared_mut_loop_pair_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_mut_loop_pair] -/
-def list_nth_shared_mut_loop_pair_fwd
+/- [loops::list_nth_shared_mut_loop_pair]: forward function -/
+def list_nth_shared_mut_loop_pair
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_shared_mut_loop_pair_loop_fwd T ls0 ls1 i
+  list_nth_shared_mut_loop_pair_loop T ls0 ls1 i
 
-/- [loops::list_nth_shared_mut_loop_pair] -/
+/- [loops::list_nth_shared_mut_loop_pair]: loop 0: backward function 1 -/
 divergent def list_nth_shared_mut_loop_pair_loop_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
@@ -563,15 +559,15 @@ divergent def list_nth_shared_mut_loop_pair_loop_back
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_mut_loop_pair] -/
+/- [loops::list_nth_shared_mut_loop_pair]: backward function 1 -/
 def list_nth_shared_mut_loop_pair_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
   :=
   list_nth_shared_mut_loop_pair_loop_back T ls0 ls1 i ret0
 
-/- [loops::list_nth_shared_mut_loop_pair_merge] -/
-divergent def list_nth_shared_mut_loop_pair_merge_loop_fwd
+/- [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: forward function -/
+divergent def list_nth_shared_mut_loop_pair_merge_loop
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
   match ls0 with
   | List.Cons x0 tl0 =>
@@ -582,16 +578,16 @@ divergent def list_nth_shared_mut_loop_pair_merge_loop_fwd
       else
         do
           let i0 ← i - (U32.ofInt 1 (by intlit))
-          list_nth_shared_mut_loop_pair_merge_loop_fwd T tl0 tl1 i0
+          list_nth_shared_mut_loop_pair_merge_loop T tl0 tl1 i0
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_mut_loop_pair_merge] -/
-def list_nth_shared_mut_loop_pair_merge_fwd
+/- [loops::list_nth_shared_mut_loop_pair_merge]: forward function -/
+def list_nth_shared_mut_loop_pair_merge
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) : Result (T × T) :=
-  list_nth_shared_mut_loop_pair_merge_loop_fwd T ls0 ls1 i
+  list_nth_shared_mut_loop_pair_merge_loop T ls0 ls1 i
 
-/- [loops::list_nth_shared_mut_loop_pair_merge] -/
+/- [loops::list_nth_shared_mut_loop_pair_merge]: loop 0: backward function 0 -/
 divergent def list_nth_shared_mut_loop_pair_merge_loop_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)
@@ -611,7 +607,7 @@ divergent def list_nth_shared_mut_loop_pair_merge_loop_back
     | List.Nil => Result.fail Error.panic
   | List.Nil => Result.fail Error.panic
 
-/- [loops::list_nth_shared_mut_loop_pair_merge] -/
+/- [loops::list_nth_shared_mut_loop_pair_merge]: backward function 0 -/
 def list_nth_shared_mut_loop_pair_merge_back
   (T : Type) (ls0 : List T) (ls1 : List T) (i : U32) (ret0 : T) :
   Result (List T)