add gcd, exgcd and seven linked-list cases

README.md

@@ -22,22 +22,22 @@ size_categories:
 
 A benchmark for measuring how well LLMs do **program verification** — not code generation — on real, human-authored problems.
 
-It has 233 problems. Each one comes with a correct C solution that has been given a formal
+It has 242 problems. Each one comes with a correct C solution that has been given a formal
 spec and checked by [**QCP**](https://www.qua.codes/en/index.html). The proofs are done in one
-of two backends, **Rocq** or **Lean 4**. All 233 have a Rocq version; 83 also have a Lean one.
+of two backends, **Rocq** or **Lean 4**. All 242 have a Rocq version; 83 also have a Lean one.
 
 The problems are in four groups, all under `benchmarks/`, next to the build files:
 
 | group | problems | C lines | source |
 |---|---:|---:|---|
 | `benchmarks/Codeforces/` | 147 | 6,899 | competitive-programming problems, grouped into `examples_shard<NN>/` slices |
-| `benchmarks/Algorithms/` | 73 | 3,986 | classic algorithms, one directory per algorithm |
-| `benchmarks/Data_structures/` | 5 | 404 | array stack, BIT and three priority-queue interfaces |
+| `benchmarks/Algorithms/` | 77 | 4,111 | classic algorithms, one directory per algorithm |
+| `benchmarks/Data_structures/` | 10 | 618 | array stack, BIT, three priority-queue interfaces, linked lists and three linked queues |
 | `benchmarks/Engineering/` | 8 | 338 | MiniSat vectors and C string / memory routines |
-| total | 233 | 11,627 | |
+| total | 242 | 11,966 | |
 
 "C lines" counts the unannotated `solution.c` — the program a model is asked to specify and
-verify. They are small by design: a median of 40 lines, 50 on average, from 5 up to 189
+verify. They are small by design: a median of 40 lines, 49 on average, from 5 up to 189
 (`Algorithms/kosaraju`). The difficulty is in the property to be proved, not in the size of the
 code.
 
@@ -93,7 +93,7 @@ backend's assertion language.
       └── groundtruth/
 ```
 
-`rocq/` is present for all 233 problems; `lean/` for 83 of them — 45 Algorithms,
+`rocq/` is present for all 242 problems; `lean/` for 83 of them — 45 Algorithms,
 34 Codeforces (14 in `examples_shard00`, 20 in `examples_shard01`), 3 Data_structures and
 1 Engineering. The `.lean` libraries mirror the corresponding `.v` files; cases without
 private definitions import shared libraries directly from the C annotations.

benchmarks/Algorithms/exgcd/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "exgcd",
+  "source": {
+    "dataset": "classical_algorithm",
+    "problem_id": "exgcd",
+    "title": "Extended Euclidean Algorithm",
+    "tags": [
+      "gcd",
+      "bezout",
+      "recursion"
+    ]
+  },
+  "stratification": {
+    "band": "unclassified",
+    "output_mode": "CONSTRUCT",
+    "interactive": false,
+    "multi_test": false
+  }
+}

benchmarks/Algorithms/exgcd/problem.md

@@ -0,0 +1,13 @@
+# Extended Euclidean Algorithm
+
+## Description
+
+Compute the greatest common divisor of two integers together with a pair of Bézout coefficients, using the recursive extended Euclidean algorithm. 
+
+## Input
+
+The function receives two integers $a$ and $b$ ($-2^{31} < a, b \le 2^{31} - 1$), and two pointers `x` and `y` to two distinct writable `int` cells.
+
+## Output
+
+Return $g = \gcd(a, b)$ and store integers in `*x` and `*y` such that $a \cdot x + b \cdot y = g$.

benchmarks/Algorithms/exgcd/rocq/groundtruth/exgcd_goal.v

@@ -0,0 +1,1035 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Local Open Scope sac.
+
+(*----- Function abs -----*)
+
+Definition abs_safety_wit_1 := 
+forall (x_pre: Z) (PreH1 : (INT_MIN < x_pre)) (PreH2 : (x_pre <= INT_MAX)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition abs_safety_wit_2 := 
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+|--
+  “ (x_pre <> (INT_MIN)) ”
+.
+
+Definition abs_return_wit_1 := 
+(
+forall (x_pre: Z) (PreH1 : (x_pre >= 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ (x_pre = (Zabs (x_pre))) ”
+  &&  emp
+) \/
+(
+forall (x_pre: Z) (PreH1 : (x_pre >= 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ (x_pre = (Zabs (x_pre))) ”
+  &&  emp
+).
+
+Definition abs_return_wit_1_split_goal_1 := 
+forall (x_pre: Z) (PreH1 : (x_pre >= 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  (x_pre = (Zabs (x_pre)))
+.
+
+Definition abs_return_wit_2 := 
+(
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((-x_pre) = (Zabs (x_pre))) ”
+  &&  emp
+) \/
+(
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((-x_pre) = (Zabs (x_pre))) ”
+  &&  emp
+).
+
+Definition abs_return_wit_2_split_goal_1 := 
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  ((-x_pre) = (Zabs (x_pre)))
+.
+
+(*----- Function exgcd -----*)
+
+Definition exgcd_safety_wit_1 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (INT_MIN < a_pre)) (PreH2 : (a_pre <= INT_MAX)) (PreH3 : (INT_MIN < b_pre)) (PreH4 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition exgcd_safety_wit_2 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (b_pre = 0)) (PreH2 : (INT_MIN < a_pre)) (PreH3 : (a_pre <= INT_MAX)) (PreH4 : (INT_MIN < b_pre)) (PreH5 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition exgcd_safety_wit_3 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre < 0)) (PreH2 : (b_pre = 0)) (PreH3 : (INT_MIN < a_pre)) (PreH4 : (a_pre <= INT_MAX)) (PreH5 : (INT_MIN < b_pre)) (PreH6 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (1 <> (INT_MIN)) ”
+.
+
+Definition exgcd_safety_wit_4 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre < 0)) (PreH2 : (b_pre = 0)) (PreH3 : (INT_MIN < a_pre)) (PreH4 : (a_pre <= INT_MAX)) (PreH5 : (INT_MIN < b_pre)) (PreH6 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (1 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 1) ”
+.
+
+Definition exgcd_safety_wit_5 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre >= 0)) (PreH2 : (b_pre = 0)) (PreH3 : (INT_MIN < a_pre)) (PreH4 : (a_pre <= INT_MAX)) (PreH5 : (INT_MIN < b_pre)) (PreH6 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition exgcd_safety_wit_6 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre = 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition exgcd_safety_wit_7 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre <> 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (1 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 1) ”
+.
+
+Definition exgcd_safety_wit_8 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre < 0)) (PreH2 : (b_pre = 0)) (PreH3 : (INT_MIN < a_pre)) (PreH4 : (a_pre <= INT_MAX)) (PreH5 : (INT_MIN < b_pre)) (PreH6 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |-> (-1))
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition exgcd_safety_wit_9 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre = 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |-> 0)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition exgcd_safety_wit_10 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre <> 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |-> 1)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition exgcd_safety_wit_11 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (b_pre <> 0)) (PreH2 : (INT_MIN < a_pre)) (PreH3 : (a_pre <= INT_MAX)) (PreH4 : (INT_MIN < b_pre)) (PreH5 : (b_pre <= INT_MAX)) ,
+  ((( &( "g" ) )) # Int  |->_)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ ((a_pre <> (INT_MIN)) \/ (b_pre <> (-1))) ” 
+  &&  “ (b_pre <> 0) ”
+.
+
+Definition exgcd_safety_wit_12 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) )) ”
+.
+
+Definition exgcd_safety_wit_13 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ (((a_pre ÷ b_pre ) * y_callee_v ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= ((a_pre ÷ b_pre ) * y_callee_v )) ”
+.
+
+Definition exgcd_safety_wit_14 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((a_pre <> (INT_MIN)) \/ (b_pre <> (-1))) ” 
+  &&  “ (b_pre <> 0) ”
+.
+
+Definition exgcd_safety_wit_15 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) )) ”
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) )) ”
+).
+
+Definition exgcd_safety_wit_15_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) <= INT_MAX) ”
+.
+
+Definition exgcd_safety_wit_15_split_goal_2 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((INT_MIN) <= (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) )) ”
+.
+
+Definition exgcd_safety_wit_16 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ (((a_pre ÷ b_pre ) * y_callee_v ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= ((a_pre ÷ b_pre ) * y_callee_v )) ”
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ (((a_pre ÷ b_pre ) * y_callee_v ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= ((a_pre ÷ b_pre ) * y_callee_v )) ”
+).
+
+Definition exgcd_safety_wit_16_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ (((a_pre ÷ b_pre ) * y_callee_v ) <= INT_MAX) ”
+.
+
+Definition exgcd_safety_wit_16_split_goal_2 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((INT_MIN) <= ((a_pre ÷ b_pre ) * y_callee_v )) ”
+.
+
+Definition exgcd_safety_wit_17 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((a_pre <> (INT_MIN)) \/ (b_pre <> (-1))) ” 
+  &&  “ (b_pre <> 0) ”
+.
+
+Definition exgcd_safety_wit_18 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) )) ”
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) )) ”
+).
+
+Definition exgcd_safety_wit_18_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) <= INT_MAX) ”
+.
+
+Definition exgcd_safety_wit_18_split_goal_2 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((INT_MIN) <= (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) )) ”
+.
+
+Definition exgcd_safety_wit_19 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ (((a_pre ÷ b_pre ) * y_callee_v ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= ((a_pre ÷ b_pre ) * y_callee_v )) ”
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ (((a_pre ÷ b_pre ) * y_callee_v ) <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= ((a_pre ÷ b_pre ) * y_callee_v )) ”
+).
+
+Definition exgcd_safety_wit_19_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ (((a_pre ÷ b_pre ) * y_callee_v ) <= INT_MAX) ”
+.
+
+Definition exgcd_safety_wit_19_split_goal_2 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((INT_MIN) <= ((a_pre ÷ b_pre ) * y_callee_v )) ”
+.
+
+Definition exgcd_safety_wit_20 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> x_callee_v)
+  **  ((x_pre) # Int  |-> y_callee_v)
+  **  ((( &( "g" ) )) # Int  |-> retval)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+|--
+  “ ((a_pre <> (INT_MIN)) \/ (b_pre <> (-1))) ” 
+  &&  “ (b_pre <> 0) ”
+.
+
+Definition exgcd_return_wit_1 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ))
+  **  ((x_pre) # Int  |-> y_callee_v)
+|--
+  EX (y_pre_v_2: Z)  (x_pre_v_2: Z) ,
+  “ (retval = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_pre_v_2 ) + (b_pre * y_pre_v_2 ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre <> 0) ” 
+  &&  “ ((a_pre % ( b_pre ) ) = 0) ” 
+  &&  “ (x_pre_v_2 = 0) ” 
+  &&  “ ((Zabs (y_pre_v_2)) <= 1) ”
+  &&  ((x_pre) # Int  |-> x_pre_v_2)
+  **  ((y_pre) # Int  |-> y_pre_v_2)
+) \/
+(
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((Zabs ((x_callee_v - ((a_pre ÷ b_pre ) * 0 ) ))) <= 1) ” 
+  &&  “ (((a_pre * 0 ) + (b_pre * (x_callee_v - ((a_pre ÷ b_pre ) * 0 ) ) ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (retval = (Zgcd (a_pre) (b_pre))) ”
+  &&  emp
+).
+
+Definition exgcd_return_wit_1_split_goal_1 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  ((Zabs ((x_callee_v - ((a_pre ÷ b_pre ) * 0 ) ))) <= 1)
+.
+
+Definition exgcd_return_wit_1_split_goal_2 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  (((a_pre * 0 ) + (b_pre * (x_callee_v - ((a_pre ÷ b_pre ) * 0 ) ) ) ) = (Zgcd (a_pre) (b_pre)))
+.
+
+Definition exgcd_return_wit_1_split_goal_3 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) = 0)) (PreH4 : ((Zabs (x_callee_v)) <= 1)) (PreH5 : (y_callee_v = 0)) (PreH6 : (b_pre <> 0)) (PreH7 : (INT_MIN < a_pre)) (PreH8 : (a_pre <= INT_MAX)) (PreH9 : (INT_MIN < b_pre)) (PreH10 : (b_pre <= INT_MAX)) ,
+  (retval = (Zgcd (a_pre) (b_pre)))
+.
+
+Definition exgcd_return_wit_2 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ))
+  **  ((x_pre) # Int  |-> y_callee_v)
+|--
+  EX (y_pre_v_3: Z)  (x_pre_v_3: Z) ,
+  “ (retval = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_pre_v_3 ) + (b_pre * y_pre_v_3 ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre <> 0) ” 
+  &&  “ ((a_pre % ( b_pre ) ) <> 0) ” 
+  &&  “ ((Zabs (x_pre_v_3)) <= ((Zabs (b_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ” 
+  &&  “ ((Zabs (y_pre_v_3)) <= ((Zabs (a_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ”
+  &&  ((x_pre) # Int  |-> x_pre_v_3)
+  **  ((y_pre) # Int  |-> y_pre_v_3)
+) \/
+(
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((Zabs ((0 - ((a_pre ÷ b_pre ) * y_callee_v ) ))) <= ((Zabs (a_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ” 
+  &&  “ ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ” 
+  &&  “ (((a_pre * y_callee_v ) + (b_pre * (0 - ((a_pre ÷ b_pre ) * y_callee_v ) ) ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (retval = (Zgcd (a_pre) (b_pre))) ”
+  &&  emp
+).
+
+Definition exgcd_return_wit_2_split_goal_1 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((Zabs ((0 - ((a_pre ÷ b_pre ) * y_callee_v ) ))) <= ((Zabs (a_pre)) ÷ (Zgcd (a_pre) (b_pre)) ))
+.
+
+Definition exgcd_return_wit_2_split_goal_2 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (a_pre) (b_pre)) ))
+.
+
+Definition exgcd_return_wit_2_split_goal_3 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  (((a_pre * y_callee_v ) + (b_pre * (0 - ((a_pre ÷ b_pre ) * y_callee_v ) ) ) ) = (Zgcd (a_pre) (b_pre)))
+.
+
+Definition exgcd_return_wit_2_split_goal_4 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) = 0)) (PreH5 : (x_callee_v = 0)) (PreH6 : ((Zabs (y_callee_v)) <= 1)) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  (retval = (Zgcd (a_pre) (b_pre)))
+.
+
+Definition exgcd_return_wit_3 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((y_pre) # Int  |-> (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ))
+  **  ((x_pre) # Int  |-> y_callee_v)
+|--
+  EX (y_pre_v_3: Z)  (x_pre_v_3: Z) ,
+  “ (retval = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_pre_v_3 ) + (b_pre * y_pre_v_3 ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre <> 0) ” 
+  &&  “ ((a_pre % ( b_pre ) ) <> 0) ” 
+  &&  “ ((Zabs (x_pre_v_3)) <= ((Zabs (b_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ” 
+  &&  “ ((Zabs (y_pre_v_3)) <= ((Zabs (a_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ”
+  &&  ((x_pre) # Int  |-> x_pre_v_3)
+  **  ((y_pre) # Int  |-> y_pre_v_3)
+) \/
+(
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((Zabs ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ))) <= ((Zabs (a_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ” 
+  &&  “ ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ” 
+  &&  “ (((a_pre * y_callee_v ) + (b_pre * (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (retval = (Zgcd (a_pre) (b_pre))) ”
+  &&  emp
+).
+
+Definition exgcd_return_wit_3_split_goal_1 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((Zabs ((x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ))) <= ((Zabs (a_pre)) ÷ (Zgcd (a_pre) (b_pre)) ))
+.
+
+Definition exgcd_return_wit_3_split_goal_2 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (a_pre) (b_pre)) ))
+.
+
+Definition exgcd_return_wit_3_split_goal_3 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  (((a_pre * y_callee_v ) + (b_pre * (x_callee_v - ((a_pre ÷ b_pre ) * y_callee_v ) ) ) ) = (Zgcd (a_pre) (b_pre)))
+.
+
+Definition exgcd_return_wit_3_split_goal_4 := 
+forall (b_pre: Z) (a_pre: Z) (y_callee_v: Z) (x_callee_v: Z) (retval: Z) (PreH1 : (retval = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH2 : (((b_pre * x_callee_v ) + ((a_pre % ( b_pre ) ) * y_callee_v ) ) = (Zgcd (b_pre) ((a_pre % ( b_pre ) ))))) (PreH3 : ((a_pre % ( b_pre ) ) <> 0)) (PreH4 : ((b_pre % ( (a_pre % ( b_pre ) ) ) ) <> 0)) (PreH5 : ((Zabs (x_callee_v)) <= ((Zabs ((a_pre % ( b_pre ) ))) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH6 : ((Zabs (y_callee_v)) <= ((Zabs (b_pre)) ÷ (Zgcd (b_pre) ((a_pre % ( b_pre ) ))) ))) (PreH7 : (b_pre <> 0)) (PreH8 : (INT_MIN < a_pre)) (PreH9 : (a_pre <= INT_MAX)) (PreH10 : (INT_MIN < b_pre)) (PreH11 : (b_pre <= INT_MAX)) ,
+  (retval = (Zgcd (a_pre) (b_pre)))
+.
+
+Definition exgcd_return_wit_4 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre < 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((x_pre) # Int  |-> (-1))
+  **  ((y_pre) # Int  |-> 0)
+|--
+  EX (y_pre_v: Z)  (x_pre_v: Z) ,
+  “ (retval = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_pre_v ) + (b_pre * y_pre_v ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre = 0) ” 
+  &&  “ ((Zabs (x_pre_v)) <= 1) ” 
+  &&  “ (y_pre_v = 0) ”
+  &&  ((x_pre) # Int  |-> x_pre_v)
+  **  ((y_pre) # Int  |-> y_pre_v)
+) \/
+(
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre < 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((Zabs ((-1))) <= 1) ” 
+  &&  “ (((a_pre * (-1) ) + (0 * 0 ) ) = (Zgcd (a_pre) (0))) ” 
+  &&  “ (retval = (Zgcd (a_pre) (0))) ”
+  &&  emp
+).
+
+Definition exgcd_return_wit_4_split_goal_1 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre < 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((Zabs ((-1))) <= 1)
+.
+
+Definition exgcd_return_wit_4_split_goal_2 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre < 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  (((a_pre * (-1) ) + (0 * 0 ) ) = (Zgcd (a_pre) (0)))
+.
+
+Definition exgcd_return_wit_4_split_goal_3 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre < 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  (retval = (Zgcd (a_pre) (0)))
+.
+
+Definition exgcd_return_wit_5 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre = 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  ((x_pre) # Int  |-> 0)
+  **  ((y_pre) # Int  |-> 0)
+|--
+  EX (y_pre_v: Z)  (x_pre_v: Z) ,
+  “ (retval = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_pre_v ) + (b_pre * y_pre_v ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre = 0) ” 
+  &&  “ ((Zabs (x_pre_v)) <= 1) ” 
+  &&  “ (y_pre_v = 0) ”
+  &&  ((x_pre) # Int  |-> x_pre_v)
+  **  ((y_pre) # Int  |-> y_pre_v)
+) \/
+(
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre = 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((Zabs (0)) <= 1) ” 
+  &&  “ (((0 * 0 ) + (0 * 0 ) ) = (Zgcd (0) (0))) ” 
+  &&  “ (retval = (Zgcd (0) (0))) ”
+  &&  emp
+).
+
+Definition exgcd_return_wit_5_split_goal_1 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre = 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  ((Zabs (0)) <= 1)
+.
+
+Definition exgcd_return_wit_5_split_goal_2 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre = 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  (((0 * 0 ) + (0 * 0 ) ) = (Zgcd (0) (0)))
+.
+
+Definition exgcd_return_wit_5_split_goal_3 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre = 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  (retval = (Zgcd (0) (0)))
+.
+
+Definition exgcd_return_wit_6 := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre <> 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  ((x_pre) # Int  |-> 1)
+  **  ((y_pre) # Int  |-> 0)
+|--
+  EX (y_pre_v: Z)  (x_pre_v: Z) ,
+  “ (retval = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_pre_v ) + (b_pre * y_pre_v ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre = 0) ” 
+  &&  “ ((Zabs (x_pre_v)) <= 1) ” 
+  &&  “ (y_pre_v = 0) ”
+  &&  ((x_pre) # Int  |-> x_pre_v)
+  **  ((y_pre) # Int  |-> y_pre_v)
+) \/
+(
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre <> 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((Zabs (1)) <= 1) ” 
+  &&  “ (((a_pre * 1 ) + (0 * 0 ) ) = (Zgcd (a_pre) (0))) ” 
+  &&  “ (retval = (Zgcd (a_pre) (0))) ”
+  &&  emp
+).
+
+Definition exgcd_return_wit_6_split_goal_1 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre <> 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  ((Zabs (1)) <= 1)
+.
+
+Definition exgcd_return_wit_6_split_goal_2 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre <> 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  (((a_pre * 1 ) + (0 * 0 ) ) = (Zgcd (a_pre) (0)))
+.
+
+Definition exgcd_return_wit_6_split_goal_3 := 
+forall (b_pre: Z) (a_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (a_pre)))) (PreH2 : (a_pre <> 0)) (PreH3 : (a_pre >= 0)) (PreH4 : (b_pre = 0)) (PreH5 : (INT_MIN < a_pre)) (PreH6 : (a_pre <= INT_MAX)) (PreH7 : (INT_MIN < b_pre)) (PreH8 : (b_pre <= INT_MAX)) ,
+  (retval = (Zgcd (a_pre) (0)))
+.
+
+Definition exgcd_partial_solve_wit_1_pure := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre < 0)) (PreH2 : (b_pre = 0)) (PreH3 : (INT_MIN < a_pre)) (PreH4 : (a_pre <= INT_MAX)) (PreH5 : (INT_MIN < b_pre)) (PreH6 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |-> (-1))
+  **  ((y_pre) # Int  |-> 0)
+|--
+  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ”
+.
+
+Definition exgcd_partial_solve_wit_1_aux := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre < 0)) (PreH2 : (b_pre = 0)) (PreH3 : (INT_MIN < a_pre)) (PreH4 : (a_pre <= INT_MAX)) (PreH5 : (INT_MIN < b_pre)) (PreH6 : (b_pre <= INT_MAX)) ,
+  ((x_pre) # Int  |-> (-1))
+  **  ((y_pre) # Int  |-> 0)
+|--
+  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (a_pre < 0) ” 
+  &&  “ (b_pre = 0) ” 
+  &&  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ”
+  &&  ((x_pre) # Int  |-> (-1))
+  **  ((y_pre) # Int  |-> 0)
+.
+
+Definition exgcd_partial_solve_wit_1 := exgcd_partial_solve_wit_1_pure -> exgcd_partial_solve_wit_1_aux.
+
+Definition exgcd_partial_solve_wit_2_pure := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre = 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |-> 0)
+  **  ((y_pre) # Int  |-> 0)
+|--
+  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ”
+.
+
+Definition exgcd_partial_solve_wit_2_aux := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre = 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((x_pre) # Int  |-> 0)
+  **  ((y_pre) # Int  |-> 0)
+|--
+  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (a_pre = 0) ” 
+  &&  “ (a_pre >= 0) ” 
+  &&  “ (b_pre = 0) ” 
+  &&  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ”
+  &&  ((x_pre) # Int  |-> 0)
+  **  ((y_pre) # Int  |-> 0)
+.
+
+Definition exgcd_partial_solve_wit_2 := exgcd_partial_solve_wit_2_pure -> exgcd_partial_solve_wit_2_aux.
+
+Definition exgcd_partial_solve_wit_3_pure := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre <> 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |-> 1)
+  **  ((y_pre) # Int  |-> 0)
+|--
+  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ”
+.
+
+Definition exgcd_partial_solve_wit_3_aux := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (a_pre <> 0)) (PreH2 : (a_pre >= 0)) (PreH3 : (b_pre = 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((x_pre) # Int  |-> 1)
+  **  ((y_pre) # Int  |-> 0)
+|--
+  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (a_pre <> 0) ” 
+  &&  “ (a_pre >= 0) ” 
+  &&  “ (b_pre = 0) ” 
+  &&  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ”
+  &&  ((x_pre) # Int  |-> 1)
+  **  ((y_pre) # Int  |-> 0)
+.
+
+Definition exgcd_partial_solve_wit_3 := exgcd_partial_solve_wit_3_pure -> exgcd_partial_solve_wit_3_aux.
+
+Definition exgcd_partial_solve_wit_4_pure := 
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (b_pre <> 0)) (PreH2 : (INT_MIN < a_pre)) (PreH3 : (a_pre <= INT_MAX)) (PreH4 : (INT_MIN < b_pre)) (PreH5 : (b_pre <= INT_MAX)) ,
+  ((( &( "g" ) )) # Int  |->_)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ” 
+  &&  “ ((a_pre % ( b_pre ) ) <= INT_MAX) ” 
+  &&  “ (INT_MIN < (a_pre % ( b_pre ) )) ”
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (b_pre >= INT_MIN)) (PreH2 : (a_pre >= INT_MIN)) (PreH3 : (b_pre <> 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "g" ) )) # Int  |->_)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (INT_MIN < (a_pre % ( b_pre ) )) ” 
+  &&  “ ((a_pre % ( b_pre ) ) <= INT_MAX) ”
+).
+
+Definition exgcd_partial_solve_wit_4_pure_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (b_pre >= INT_MIN)) (PreH2 : (a_pre >= INT_MIN)) (PreH3 : (b_pre <> 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "g" ) )) # Int  |->_)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (INT_MIN < (a_pre % ( b_pre ) )) ”
+.
+
+Definition exgcd_partial_solve_wit_4_pure_split_goal_2 := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (b_pre >= INT_MIN)) (PreH2 : (a_pre >= INT_MIN)) (PreH3 : (b_pre <> 0)) (PreH4 : (INT_MIN < a_pre)) (PreH5 : (a_pre <= INT_MAX)) (PreH6 : (INT_MIN < b_pre)) (PreH7 : (b_pre <= INT_MAX)) ,
+  ((( &( "g" ) )) # Int  |->_)
+  **  ((( &( "a" ) )) # Int  |-> a_pre)
+  **  ((( &( "b" ) )) # Int  |-> b_pre)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "y" ) )) # Ptr  |-> y_pre)
+  **  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ ((a_pre % ( b_pre ) ) <= INT_MAX) ”
+.
+
+Definition exgcd_partial_solve_wit_4_aux := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) (PreH1 : (b_pre <> 0)) (PreH2 : (INT_MIN < a_pre)) (PreH3 : (a_pre <= INT_MAX)) (PreH4 : (INT_MIN < b_pre)) (PreH5 : (b_pre <= INT_MAX)) ,
+  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ” 
+  &&  “ ((a_pre % ( b_pre ) ) <= INT_MAX) ” 
+  &&  “ (INT_MIN < (a_pre % ( b_pre ) )) ” 
+  &&  “ (b_pre <> 0) ” 
+  &&  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ”
+  &&  ((y_pre) # Int  |->_)
+  **  ((x_pre) # Int  |->_)
+.
+
+Definition exgcd_partial_solve_wit_4 := exgcd_partial_solve_wit_4_pure -> exgcd_partial_solve_wit_4_aux.
+
+Definition exgcd_derive_Inter_by_Proof := 
+forall (y_pre: Z) (x_pre: Z) (b_pre: Z) (a_pre: Z) ,
+  “ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ”
+  &&  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_)
+|--
+  (“ (INT_MIN < a_pre) ” 
+  &&  “ (a_pre <= INT_MAX) ” 
+  &&  “ (INT_MIN < b_pre) ” 
+  &&  “ (b_pre <= INT_MAX) ”
+  &&  ((x_pre) # Int  |->_)
+  **  ((y_pre) # Int  |->_))
+  **
+  (((EX y_callee_v x_callee_v retval_2,
+  “ (retval_2 = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_callee_v ) + (b_pre * y_callee_v ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre = 0) ” 
+  &&  “ ((Zabs (x_callee_v)) <= 1) ” 
+  &&  “ (y_callee_v = 0) ”
+  &&  ((x_pre) # Int  |-> x_callee_v)
+  **  ((y_pre) # Int  |-> y_callee_v))
+  ||
+  (EX y_callee_v_2 x_callee_v_2 retval_2,
+  “ (retval_2 = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_callee_v_2 ) + (b_pre * y_callee_v_2 ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre <> 0) ” 
+  &&  “ ((a_pre % ( b_pre ) ) = 0) ” 
+  &&  “ (x_callee_v_2 = 0) ” 
+  &&  “ ((Zabs (y_callee_v_2)) <= 1) ”
+  &&  ((x_pre) # Int  |-> x_callee_v_2)
+  **  ((y_pre) # Int  |-> y_callee_v_2))
+  ||
+  (EX y_callee_v_3 x_callee_v_3 retval_2,
+  “ (retval_2 = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_callee_v_3 ) + (b_pre * y_callee_v_3 ) ) = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (b_pre <> 0) ” 
+  &&  “ ((a_pre % ( b_pre ) ) <> 0) ” 
+  &&  “ ((Zabs (x_callee_v_3)) <= ((Zabs (b_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ” 
+  &&  “ ((Zabs (y_callee_v_3)) <= ((Zabs (a_pre)) ÷ (Zgcd (a_pre) (b_pre)) )) ”
+  &&  ((x_pre) # Int  |-> x_callee_v_3)
+  **  ((y_pre) # Int  |-> y_callee_v_3)))
+  -*
+  (EX y_pre_v x_pre_v retval,
+  “ (retval = (Zgcd (a_pre) (b_pre))) ” 
+  &&  “ (((a_pre * x_pre_v ) + (b_pre * y_pre_v ) ) = (Zgcd (a_pre) (b_pre))) ”
+  &&  ((x_pre) # Int  |-> x_pre_v)
+  **  ((y_pre) # Int  |-> y_pre_v)))
+.
+
+Module Type VC_Correct.
+
+
+Axiom proof_of_abs_safety_wit_1 : abs_safety_wit_1.
+Axiom proof_of_abs_safety_wit_2 : abs_safety_wit_2.
+Axiom proof_of_abs_return_wit_1 : abs_return_wit_1.
+Axiom proof_of_abs_return_wit_2 : abs_return_wit_2.
+Axiom proof_of_exgcd_safety_wit_1 : exgcd_safety_wit_1.
+Axiom proof_of_exgcd_safety_wit_2 : exgcd_safety_wit_2.
+Axiom proof_of_exgcd_safety_wit_3 : exgcd_safety_wit_3.
+Axiom proof_of_exgcd_safety_wit_4 : exgcd_safety_wit_4.
+Axiom proof_of_exgcd_safety_wit_5 : exgcd_safety_wit_5.
+Axiom proof_of_exgcd_safety_wit_6 : exgcd_safety_wit_6.
+Axiom proof_of_exgcd_safety_wit_7 : exgcd_safety_wit_7.
+Axiom proof_of_exgcd_safety_wit_8 : exgcd_safety_wit_8.
+Axiom proof_of_exgcd_safety_wit_9 : exgcd_safety_wit_9.
+Axiom proof_of_exgcd_safety_wit_10 : exgcd_safety_wit_10.
+Axiom proof_of_exgcd_safety_wit_11 : exgcd_safety_wit_11.
+Axiom proof_of_exgcd_safety_wit_12 : exgcd_safety_wit_12.
+Axiom proof_of_exgcd_safety_wit_13 : exgcd_safety_wit_13.
+Axiom proof_of_exgcd_safety_wit_14 : exgcd_safety_wit_14.
+Axiom proof_of_exgcd_safety_wit_15 : exgcd_safety_wit_15.
+Axiom proof_of_exgcd_safety_wit_16 : exgcd_safety_wit_16.
+Axiom proof_of_exgcd_safety_wit_17 : exgcd_safety_wit_17.
+Axiom proof_of_exgcd_safety_wit_18 : exgcd_safety_wit_18.
+Axiom proof_of_exgcd_safety_wit_19 : exgcd_safety_wit_19.
+Axiom proof_of_exgcd_safety_wit_20 : exgcd_safety_wit_20.
+Axiom proof_of_exgcd_return_wit_1 : exgcd_return_wit_1.
+Axiom proof_of_exgcd_return_wit_2 : exgcd_return_wit_2.
+Axiom proof_of_exgcd_return_wit_3 : exgcd_return_wit_3.
+Axiom proof_of_exgcd_return_wit_4 : exgcd_return_wit_4.
+Axiom proof_of_exgcd_return_wit_5 : exgcd_return_wit_5.
+Axiom proof_of_exgcd_return_wit_6 : exgcd_return_wit_6.
+Axiom proof_of_exgcd_partial_solve_wit_1_pure : exgcd_partial_solve_wit_1_pure.
+Axiom proof_of_exgcd_partial_solve_wit_1 : exgcd_partial_solve_wit_1.
+Axiom proof_of_exgcd_partial_solve_wit_2_pure : exgcd_partial_solve_wit_2_pure.
+Axiom proof_of_exgcd_partial_solve_wit_2 : exgcd_partial_solve_wit_2.
+Axiom proof_of_exgcd_partial_solve_wit_3_pure : exgcd_partial_solve_wit_3_pure.
+Axiom proof_of_exgcd_partial_solve_wit_3 : exgcd_partial_solve_wit_3.
+Axiom proof_of_exgcd_partial_solve_wit_4_pure : exgcd_partial_solve_wit_4_pure.
+Axiom proof_of_exgcd_partial_solve_wit_4 : exgcd_partial_solve_wit_4.
+Axiom proof_of_exgcd_derive_Inter_by_Proof : exgcd_derive_Inter_by_Proof.
+
+End VC_Correct.

benchmarks/Algorithms/exgcd/rocq/groundtruth/exgcd_goal_check.v

@@ -0,0 +1,6 @@
+From PVbench.Algorithms.exgcd.rocq.groundtruth Require Import exgcd_goal exgcd_proof_auto exgcd_proof_manual.
+
+Module VC_Correctness : VC_Correct.
+  Include exgcd_proof_auto.
+  Include exgcd_proof_manual.
+End VC_Correctness.

benchmarks/Algorithms/exgcd/rocq/groundtruth/exgcd_proof_auto.v

@@ -0,0 +1,96 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.exgcd.rocq.groundtruth Require Import exgcd_goal.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Local Open Scope sac.
+
+Lemma proof_of_abs_safety_wit_1 : abs_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_abs_safety_wit_2 : abs_safety_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_1 : exgcd_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_2 : exgcd_safety_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_3 : exgcd_safety_wit_3.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_4 : exgcd_safety_wit_4.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_5 : exgcd_safety_wit_5.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_6 : exgcd_safety_wit_6.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_7 : exgcd_safety_wit_7.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_8 : exgcd_safety_wit_8.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_9 : exgcd_safety_wit_9.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_10 : exgcd_safety_wit_10.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_11 : exgcd_safety_wit_11.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_12 : exgcd_safety_wit_12.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_13 : exgcd_safety_wit_13.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_14 : exgcd_safety_wit_14.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_17 : exgcd_safety_wit_17.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_safety_wit_20 : exgcd_safety_wit_20.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_partial_solve_wit_1_pure : exgcd_partial_solve_wit_1_pure.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_partial_solve_wit_1 : exgcd_partial_solve_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_partial_solve_wit_2_pure : exgcd_partial_solve_wit_2_pure.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_partial_solve_wit_2 : exgcd_partial_solve_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_partial_solve_wit_3_pure : exgcd_partial_solve_wit_3_pure.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_partial_solve_wit_3 : exgcd_partial_solve_wit_3.
+Proof. Admitted. 
+
+Lemma proof_of_exgcd_partial_solve_wit_4 : exgcd_partial_solve_wit_4.
+Proof. Admitted. 
+

benchmarks/Algorithms/exgcd/rocq/groundtruth/exgcd_proof_manual.v

@@ -0,0 +1,394 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.exgcd.rocq.groundtruth Require Import exgcd_goal.
+From PVbench.Algorithms.exgcd.rocq.groundtruth Require Import exgcd_proof_auto.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import PVbench.Algorithms.exgcd.rocq.groundtruth.proof_lib.
+Local Open Scope sac.
+
+
+
+Lemma proof_of_exgcd_safety_wit_15_split_goal_1 : exgcd_safety_wit_15_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  assert (Zabs (a_pre ÷ b_pre * y_callee_v) <= 2147483647).
+  { rewrite Z.abs_mul.
+    rewrite <- Z.quot_abs by lia.
+    pose proof Z.quot_le_upper_bound (Zabs a_pre) (Zabs b_pre) 2147483647 ltac:(lia) ltac:(lia).
+    nia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_15_split_goal_2 : exgcd_safety_wit_15_split_goal_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  assert (Zabs (a_pre ÷ b_pre * y_callee_v) <= 2147483647).
+  { rewrite Z.abs_mul.
+    rewrite <- Z.quot_abs by lia.
+    pose proof Z.quot_le_upper_bound (Zabs a_pre) (Zabs b_pre) 2147483647 ltac:(lia) ltac:(lia).
+    nia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_15 : exgcd_safety_wit_15.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_safety_wit_15_split_goal_1.
+  - Goal_apply proof_of_exgcd_safety_wit_15_split_goal_2.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_16_split_goal_1 : exgcd_safety_wit_16_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  assert (Zabs (a_pre ÷ b_pre * y_callee_v) <= 2147483647).
+  { rewrite Z.abs_mul.
+    rewrite <- Z.quot_abs by lia.
+    pose proof Z.quot_le_upper_bound (Zabs a_pre) (Zabs b_pre) 2147483647 ltac:(lia) ltac:(lia).
+    nia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_16_split_goal_2 : exgcd_safety_wit_16_split_goal_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  assert (Zabs (a_pre ÷ b_pre * y_callee_v) <= 2147483647).
+  { rewrite Z.abs_mul.
+    rewrite <- Z.quot_abs by lia.
+    pose proof Z.quot_le_upper_bound (Zabs a_pre) (Zabs b_pre) 2147483647 ltac:(lia) ltac:(lia).
+    nia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_16 : exgcd_safety_wit_16.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_safety_wit_16_split_goal_1.
+  - Goal_apply proof_of_exgcd_safety_wit_16_split_goal_2.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_18_split_goal_1 : exgcd_safety_wit_18_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  pose proof exgcd_reduction a_pre b_pre x_callee_v y_callee_v PreH7 PreH5 PreH6.
+  pose proof Z_gcd_pos_l b_pre (a_pre % (b_pre)) PreH7.
+  assert (Zabs a_pre ÷ Zgcd b_pre (a_pre % (b_pre)) <= 2147483647).
+  { apply Z.quot_le_upper_bound; lia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_18_split_goal_2 : exgcd_safety_wit_18_split_goal_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  pose proof exgcd_reduction a_pre b_pre x_callee_v y_callee_v PreH7 PreH5 PreH6.
+  pose proof Z_gcd_pos_l b_pre (a_pre % (b_pre)) PreH7.
+  assert (Zabs a_pre ÷ Zgcd b_pre (a_pre % (b_pre)) <= 2147483647).
+  { apply Z.quot_le_upper_bound; lia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_18 : exgcd_safety_wit_18.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_safety_wit_18_split_goal_1.
+  - Goal_apply proof_of_exgcd_safety_wit_18_split_goal_2.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_19_split_goal_1 : exgcd_safety_wit_19_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  pose proof Z_gcd_pos_l b_pre (a_pre % (b_pre)) PreH7.
+  assert (Zabs b_pre ÷ Zgcd b_pre (a_pre % (b_pre)) <= Zabs b_pre).
+  { apply Z.quot_le_upper_bound; nia. }
+  pose proof Z_abs_quot_rem a_pre b_pre PreH7.
+  assert (Zabs (a_pre ÷ b_pre * y_callee_v) <= Zabs a_pre).
+  { rewrite Z.abs_mul. nia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_19_split_goal_2 : exgcd_safety_wit_19_split_goal_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  pose proof Z_gcd_pos_l b_pre (a_pre % (b_pre)) PreH7.
+  assert (Zabs b_pre ÷ Zgcd b_pre (a_pre % (b_pre)) <= Zabs b_pre).
+  { apply Z.quot_le_upper_bound; nia. }
+  pose proof Z_abs_quot_rem a_pre b_pre PreH7.
+  assert (Zabs (a_pre ÷ b_pre * y_callee_v) <= Zabs a_pre).
+  { rewrite Z.abs_mul. nia. }
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_safety_wit_19 : exgcd_safety_wit_19.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_safety_wit_19_split_goal_1.
+  - Goal_apply proof_of_exgcd_safety_wit_19_split_goal_2.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_1_split_goal_1 : exgcd_return_wit_1_split_goal_1.
+Proof.
+  unfold exgcd_return_wit_1_split_goal_1; intros.
+  subst y_callee_v. lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_1_split_goal_2 : exgcd_return_wit_1_split_goal_2.
+Proof.
+  unfold exgcd_return_wit_1_split_goal_2; intros.
+  subst y_callee_v.
+  rewrite <- exgcd_gcd_step by auto.
+  nia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_1_split_goal_3 : exgcd_return_wit_1_split_goal_3.
+Proof.
+  unfold exgcd_return_wit_1_split_goal_3; intros.
+  subst retval.
+  apply exgcd_gcd_step; auto.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_1 : exgcd_return_wit_1.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_return_wit_1_split_goal_1.
+  - Goal_apply proof_of_exgcd_return_wit_1_split_goal_2.
+  - Goal_apply proof_of_exgcd_return_wit_1_split_goal_3.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_2_split_goal_1 : exgcd_return_wit_2_split_goal_1.
+Proof.
+  unfold exgcd_return_wit_2_split_goal_1; intros.
+  rewrite (exgcd_gcd_last_rem a_pre b_pre) by auto.
+  pose proof Z.rem_bound_abs a_pre b_pre PreH7.
+  replace (0 - a_pre ÷ b_pre * y_callee_v) with (-(a_pre ÷ b_pre * y_callee_v)) by lia.
+  rewrite Z.abs_opp, Z.abs_mul.
+  apply (Z.le_trans _ (Zabs (a_pre ÷ b_pre))); [nia |].
+  rewrite <- (Z.quot_abs _ _ PreH7).
+  pose proof Z.abs_nonneg a_pre.
+  apply Z.quot_le_compat_l; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_2_split_goal_2 : exgcd_return_wit_2_split_goal_2.
+Proof.
+  unfold exgcd_return_wit_2_split_goal_2; intros.
+  rewrite (exgcd_gcd_last_rem a_pre b_pre) by auto.
+  pose proof Z.rem_bound_abs a_pre b_pre PreH7.
+  apply (Z.le_trans _ (Zabs b_pre ÷ Zabs b_pre)).
+  { rewrite Z.quot_same; lia. }
+  apply Z.quot_le_compat_l; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_2_split_goal_3 : exgcd_return_wit_2_split_goal_3.
+Proof.
+  unfold exgcd_return_wit_2_split_goal_3; intros.
+  subst x_callee_v.
+  rewrite <- exgcd_gcd_step by auto.
+  rewrite <- PreH2.
+  pose proof Z.quot_rem a_pre b_pre PreH7.
+  nia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_2_split_goal_4 : exgcd_return_wit_2_split_goal_4.
+Proof.
+  unfold exgcd_return_wit_2_split_goal_4; intros.
+  subst retval.
+  apply exgcd_gcd_step; auto.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_2 : exgcd_return_wit_2.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_return_wit_2_split_goal_1.
+  - Goal_apply proof_of_exgcd_return_wit_2_split_goal_2.
+  - Goal_apply proof_of_exgcd_return_wit_2_split_goal_3.
+  - Goal_apply proof_of_exgcd_return_wit_2_split_goal_4.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_3_split_goal_1 : exgcd_return_wit_3_split_goal_1.
+Proof.
+  unfold exgcd_return_wit_3_split_goal_1; intros.
+  rewrite <- exgcd_gcd_step by auto.
+  apply exgcd_reduction; auto.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_3_split_goal_2 : exgcd_return_wit_3_split_goal_2.
+Proof.
+  unfold exgcd_return_wit_3_split_goal_2; intros.
+  rewrite <- exgcd_gcd_step by auto.
+  exact PreH6.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_3_split_goal_3 : exgcd_return_wit_3_split_goal_3.
+Proof.
+  unfold exgcd_return_wit_3_split_goal_3; intros.
+  rewrite <- exgcd_gcd_step by auto.
+  rewrite <- PreH2.
+  pose proof Z.quot_rem a_pre b_pre PreH7.
+  nia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_3_split_goal_4 : exgcd_return_wit_3_split_goal_4.
+Proof.
+  unfold exgcd_return_wit_3_split_goal_4; intros.
+  subst retval.
+  apply exgcd_gcd_step; auto.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_3 : exgcd_return_wit_3.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_return_wit_3_split_goal_1.
+  - Goal_apply proof_of_exgcd_return_wit_3_split_goal_2.
+  - Goal_apply proof_of_exgcd_return_wit_3_split_goal_3.
+  - Goal_apply proof_of_exgcd_return_wit_3_split_goal_4.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_4_split_goal_1 : exgcd_return_wit_4_split_goal_1.
+Proof.
+  unfold exgcd_return_wit_4_split_goal_1; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_4_split_goal_2 : exgcd_return_wit_4_split_goal_2.
+Proof.
+  unfold exgcd_return_wit_4_split_goal_2; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_4_split_goal_3 : exgcd_return_wit_4_split_goal_3.
+Proof.
+  unfold exgcd_return_wit_4_split_goal_3; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_4 : exgcd_return_wit_4.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_return_wit_4_split_goal_1.
+  - Goal_apply proof_of_exgcd_return_wit_4_split_goal_2.
+  - Goal_apply proof_of_exgcd_return_wit_4_split_goal_3.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_5_split_goal_1 : exgcd_return_wit_5_split_goal_1.
+Proof.
+  unfold exgcd_return_wit_5_split_goal_1; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_5_split_goal_2 : exgcd_return_wit_5_split_goal_2.
+Proof.
+  unfold exgcd_return_wit_5_split_goal_2; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_5_split_goal_3 : exgcd_return_wit_5_split_goal_3.
+Proof.
+  unfold exgcd_return_wit_5_split_goal_3; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_5 : exgcd_return_wit_5.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_return_wit_5_split_goal_1.
+  - Goal_apply proof_of_exgcd_return_wit_5_split_goal_2.
+  - Goal_apply proof_of_exgcd_return_wit_5_split_goal_3.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_6_split_goal_1 : exgcd_return_wit_6_split_goal_1.
+Proof.
+  unfold exgcd_return_wit_6_split_goal_1; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_6_split_goal_2 : exgcd_return_wit_6_split_goal_2.
+Proof.
+  unfold exgcd_return_wit_6_split_goal_2; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_6_split_goal_3 : exgcd_return_wit_6_split_goal_3.
+Proof.
+  unfold exgcd_return_wit_6_split_goal_3; intros.
+  subst; rewrite ?Z.gcd_0_r; simpl; lia.
+Qed.
+
+Lemma proof_of_exgcd_return_wit_6 : exgcd_return_wit_6.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_return_wit_6_split_goal_1.
+  - Goal_apply proof_of_exgcd_return_wit_6_split_goal_2.
+  - Goal_apply proof_of_exgcd_return_wit_6_split_goal_3.
+Qed.
+
+Lemma proof_of_exgcd_partial_solve_wit_4_pure_split_goal_1 : exgcd_partial_solve_wit_4_pure_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  pose proof Z.rem_bound_abs a_pre b_pre PreH3.
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_partial_solve_wit_4_pure_split_goal_2 : exgcd_partial_solve_wit_4_pure_split_goal_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  pose proof Z.rem_bound_abs a_pre b_pre PreH3.
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_exgcd_partial_solve_wit_4_pure : exgcd_partial_solve_wit_4_pure.
+Proof.
+  aggressive_pre_process.
+  - Goal_apply proof_of_exgcd_partial_solve_wit_4_pure_split_goal_1.
+  - Goal_apply proof_of_exgcd_partial_solve_wit_4_pure_split_goal_2.
+Qed.
+
+Lemma proof_of_exgcd_derive_Inter_by_Proof : exgcd_derive_Inter_by_Proof.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  split_pure_spatial.
+  - cancel (x_pre # Int |->_). cancel (y_pre # Int |->_).
+    apply derivable1_wand_sepcon_adjoint.
+    eapply derivable1_trans. { apply derivable1_sepcon_comm. }
+    eapply derivable1_trans. { apply derivable1_sepcon_emp_l. }
+    repeat apply derivable1_orp_elim.
+    all: Intros y x r; Exists y x r.
+    all: split_pure_spatial; [cancel | split_pures; dump_pre_spatial; auto].
+  - split_pures; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_abs_return_wit_1_split_goal_1 : abs_return_wit_1_split_goal_1.
+Proof.
+  unfold abs_return_wit_1_split_goal_1; intros.
+  lia.
+Qed.
+
+Lemma proof_of_abs_return_wit_1 : abs_return_wit_1.
+Proof.
+  aggressive_pre_process.
+  Goal_apply proof_of_abs_return_wit_1_split_goal_1.
+Qed.
+
+Lemma proof_of_abs_return_wit_2_split_goal_1 : abs_return_wit_2_split_goal_1.
+Proof.
+  unfold abs_return_wit_2_split_goal_1; intros.
+  lia.
+Qed.
+
+Lemma proof_of_abs_return_wit_2 : abs_return_wit_2.
+Proof.
+  aggressive_pre_process.
+  Goal_apply proof_of_abs_return_wit_2_split_goal_1.
+Qed.

benchmarks/Algorithms/exgcd/rocq/groundtruth/proof_lib.v

@@ -0,0 +1,181 @@
+(* Supporting lemmas for exgcd: Bezout-coefficient bounds across one Euclid step. *)
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.micromega.Psatz.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Local Open Scope Z_scope.
+
+Lemma Zabs_triangle: forall a b, Zabs(a - b) <= Zabs a + Zabs b.
+Proof. lia. Qed.
+
+Lemma Z_gcd_divide_l: forall a b, exists a', a = a' * (Zgcd a b).
+Proof.
+  intros.
+  pose proof Z.gcd_divide_l a b.
+  unfold Z.divide in H.
+  exact H.
+Qed.
+
+Lemma Z_gcd_divide_r: forall a b, exists b', b = b' * (Zgcd a b).
+Proof.
+  intros.
+  pose proof Z.gcd_divide_r a b.
+  unfold Z.divide in H.
+  exact H.
+Qed.
+
+Lemma Z_abs_quot_rem:
+  forall a b: Z, b <> 0 -> Zabs (a % (b)) + Zabs (a ÷ b) * Zabs b = Zabs a.
+Proof.
+  intros.
+  assert(Zabs b <> 0) by lia.
+  pose proof Z.quot_rem (Zabs a) (Zabs b) H0.
+  rewrite <- Z.quot_abs. 2 : lia.
+  rewrite <- Z.rem_abs. 2 : lia.
+  lia.
+Qed.
+
+Lemma Z_gcd_pos_l:
+  forall a b, a <> 0 -> Zgcd a b > 0.
+Proof.
+  intros.
+  assert(Zgcd a b <> 0). {
+    intros. intro.
+    pose proof Z.gcd_eq_0_l a b.
+    lia.
+  }
+  pose proof Z.gcd_nonneg a b.
+  lia.
+Qed.
+
+Lemma Z_gcd_pos_r:
+  forall a b, b <> 0 -> Zgcd a b > 0.
+Proof.
+  intros.
+  assert(Zgcd a b <> 0). {
+    intros. intro.
+    pose proof Z.gcd_eq_0_r a b.
+    lia.
+  }
+  pose proof Z.gcd_nonneg a b.
+  lia.
+Qed.
+
+(* Proof goal: 
+  |x'| <= |(a % b) / g|
+  |y'| <= |b / g|
+  x = y'
+  y = x' - (a / b) * y'
+  ===> 
+  |x| <= |b / g|
+  |y| <= |a / g|
+
+  informal Proof:
+  |y| =  |x' - (a / b) * y'|
+      <= |x'| + |a / b| * |y'|
+      <= |(a % b) / g| + |a / b| * |b / g|
+      =  |(|a % b| + |a / b| * |b|) / g|     (since g | (a % b) and g | b)
+      =  |a / g|
+*)
+
+Lemma exgcd_reduction_pre:
+  forall a b y, 
+  b <> 0 ->
+  Zabs y <= Zabs b ÷ Zgcd b (a % (b)) ->
+  Zabs (a ÷ b * y) <= Zabs (a ÷ b) * (Zabs b ÷ Zgcd b (a % (b))).
+Proof.
+  intros.
+  rewrite Z.abs_mul. nia.
+Qed.
+
+Lemma exgcd_reduction':
+  forall a b x y, 
+  b <> 0 ->
+  Zabs x <= Zabs (a % (b)) ÷ Zgcd b (a % (b)) -> 
+  Zabs y <= Zabs b ÷ Zgcd b (a % (b)) ->
+  Zabs (x) + Zabs (a ÷ b * y) <= Zabs a ÷ Zgcd b (a % (b)).
+Proof.
+  intros.
+  eapply Z.le_trans. 1: apply (Zplus_le_compat_r _ _ _ H0).
+  pose proof exgcd_reduction_pre a b y H H1.
+  eapply Z.le_trans. 1: apply (Zplus_le_compat_l _ _ _ H2).
+  replace (Zabs (a % (b)) ÷ Zgcd b (a % (b)) + 
+          Zabs (a ÷ b) * (Zabs b ÷ Zgcd b (a % (b)))) 
+    with (Zabs(((Zabs(a % (b))) + Zabs(a ÷ b) * Zabs(b)) ÷ Zgcd b (a % (b)))).
+  2: {
+    replace (Zgcd b (a % (b))) with (Zgcd a b) in *.
+    2: { rewrite Z.gcd_comm. rewrite <- Z.gcd_rem. rewrite Z.gcd_comm. lia. lia. }
+    pose proof Z_gcd_divide_l a b as H_adiv.
+    pose proof Z_gcd_divide_r a b as H_bdiv.
+    destruct H_adiv as [a' H_adiv].
+    destruct H_bdiv as [b' H_bdiv].
+    pose proof Z_gcd_pos_r a b H.
+    set (g := Zgcd a b) in *.
+    replace (a % (b)) with (a' % (b') * g).
+    2: { rewrite H_adiv, H_bdiv. rewrite Zquot.Zmult_rem_distr_r. reflexivity. }
+    replace (a ÷ b) with (a' ÷ b').
+    2: { rewrite H_adiv, H_bdiv. rewrite Zquot.Zquot_mult_cancel_r; lia. }
+    replace (Zabs (a' ÷ b') * (Zabs b ÷ g)) with (Zabs (a' ÷ b') * Zabs b ÷ g).
+    2: { rewrite Z.divide_quot_mul_exact; try lia. 
+        unfold Z.divide.
+        exists (Z.abs b').
+        rewrite H_bdiv.
+        replace g with (Zabs g) at 2 by lia.
+        apply Z.abs_mul. }
+    replace (Zabs ((Zabs (a' % (b') * g) + Zabs (a' ÷ b') * Zabs b) ÷ g)) 
+      with ((Zabs (a' % (b') * g) + Zabs (a' ÷ b') * Zabs b) ÷ g).
+    2: {
+      pose proof Z.abs_eq_iff ((Zabs (a' % (b') * g) + Zabs (a' ÷ b') * Zabs b) ÷ g) as H_abspos.
+      rewrite (proj2 H_abspos). 1 : reflexivity.
+      assert((Zabs (a' % (b') * g) + Zabs (a' ÷ b') * Zabs b) >= 0) by lia.
+      apply Z.quot_pos; lia.
+    }
+    replace (Zabs b) with (Zabs b' * g) by lia.
+    rewrite Z.mul_assoc.
+    rewrite Zquot.Z_quot_plus.
+    + rewrite Z.quot_mul; lia.
+    + lia.
+    + lia. 
+  }
+  pose proof Z_gcd_pos_l b (a % (b)) H.
+  rewrite <- Z.quot_abs by ltac:(lia).
+  rewrite Z_abs_quot_rem by ltac:(lia).
+  rewrite Z.abs_idemp.
+  replace (Zabs (Zgcd b (a % (b)))) with (Zgcd b (a % (b))) by lia.
+  lia.
+Qed.
+
+Lemma exgcd_reduction:
+  forall a b x y, 
+  b <> 0 ->
+  Zabs x <= Zabs (a % (b)) ÷ Zgcd b (a % (b)) -> 
+  Zabs y <= Zabs b ÷ Zgcd b (a % (b)) ->
+  Zabs (x - a ÷ b * y) <= Zabs a ÷ Zgcd b (a % (b)).
+Proof.
+  intros.
+  eapply Z.le_trans. 1: apply Zabs_triangle.
+  apply (exgcd_reduction' _ _ _ _ H H0 H1).
+Qed.
+
+
+(* One Euclid step preserves the gcd. *)
+Lemma exgcd_gcd_step:
+  forall a b, b <> 0 -> Zgcd b (a % (b)) = Zgcd a b.
+Proof.
+  intros.
+  rewrite Z.gcd_comm, Z.gcd_rem by auto.
+  apply Z.gcd_comm.
+Qed.
+
+(* When the remainder divides the divisor, it is the gcd up to sign. *)
+Lemma exgcd_gcd_last_rem:
+  forall a b, b <> 0 -> a % (b) <> 0 -> b % (a % (b)) = 0 ->
+  Zgcd a b = Zabs (a % (b)).
+Proof.
+  intros.
+  rewrite <- exgcd_gcd_step by auto.
+  rewrite Z.gcd_comm.
+  rewrite <- (Z.gcd_rem b (a % (b))) by auto.
+  rewrite H1.
+  apply Z.gcd_0_l.
+Qed.

benchmarks/Algorithms/exgcd/rocq/solution_annotated.c

@@ -0,0 +1,55 @@
+/*@ Extern Coq (Zgcd: Z -> Z -> Z)
+               (Zabs: Z -> Z) */
+
+int abs(int x)
+/*@ Require
+      INT_MIN < x && x <= INT_MAX && emp
+    Ensure
+      __return == Zabs(x) && emp
+*/
+{
+  if (x < 0) {
+    return -x;
+  }
+  return x;
+}
+
+/* The public contract, derived from the stronger one the body is verified against. */
+int exgcd(int a, int b, int *x, int *y)
+/*@ Inter <= Proof
+    Require
+      INT_MIN < a && a <= INT_MAX && INT_MIN < b && b <= INT_MAX &&
+      has_int_permission(x) * has_int_permission(y)
+    Ensure
+      __return == Zgcd(a, b) && a * (*x) + b * (*y) == Zgcd(a, b)
+*/
+;
+
+/* The coefficient bounds keep the recursive update free of overflow. */
+int exgcd(int a, int b, int *x, int *y)
+/*@ Proof
+    Require
+      INT_MIN < a && a <= INT_MAX && INT_MIN < b && b <= INT_MAX &&
+      has_int_permission(x) * has_int_permission(y)
+    Ensure
+      (__return == Zgcd(a, b) && a * (*x) + b * (*y) == Zgcd(a, b) && b == 0 && Zabs(*x) <= 1 && (*y) == 0) ||
+      (__return == Zgcd(a, b) && a * (*x) + b * (*y) == Zgcd(a, b) && b != 0 && a % b == 0 && (*x) == 0 && Zabs(*y) <= 1) ||
+      (__return == Zgcd(a, b) && a * (*x) + b * (*y) == Zgcd(a, b) && b != 0 && a % b != 0 &&
+        Zabs(*x) <= Zabs(b) / Zgcd(a, b) && Zabs(*y) <= Zabs(a) / Zgcd(a, b))
+*/
+{
+    if (b == 0) {
+        if (a < 0) {
+          *x = -1;
+        } else if (a == 0) {
+          *x = 0;
+        } else {
+          *x = 1;
+        }
+        *y = 0;
+        return abs(a);
+    }
+    int g = exgcd(b, a % b, y, x);
+    *y -= (a / b) * (*x);
+    return g;
+}

benchmarks/Algorithms/exgcd/rocq/solution_spec.c

@@ -0,0 +1,33 @@
+/*@ Extern Coq (Zgcd: Z -> Z -> Z) */
+
+int abs(int x)
+{
+  if (x < 0) {
+    return -x;
+  }
+  return x;
+}
+
+int exgcd(int a, int b, int *x, int *y)
+/*@ Require
+      INT_MIN < a && a <= INT_MAX && INT_MIN < b && b <= INT_MAX &&
+      has_int_permission(x) * has_int_permission(y)
+    Ensure
+      __return == Zgcd(a, b) && a * (*x) + b * (*y) == Zgcd(a, b)
+*/
+{
+    if (b == 0) {
+        if (a < 0) {
+          *x = -1;
+        } else if (a == 0) {
+          *x = 0;
+        } else {
+          *x = 1;
+        }
+        *y = 0;
+        return abs(a);
+    }
+    int g = exgcd(b, a % b, y, x);
+    *y -= (a / b) * (*x);
+    return g;
+}

benchmarks/Algorithms/exgcd/solution.c

@@ -0,0 +1,25 @@
+int abs(int x)
+{
+  if (x < 0) {
+    return -x;
+  }
+  return x;
+}
+
+int exgcd(int a, int b, int *x, int *y)
+{
+    if (b == 0) {
+        if (a < 0) {
+          *x = -1;
+        } else if (a == 0) {
+          *x = 0;
+        } else {
+          *x = 1;
+        }
+        *y = 0;
+        return abs(a);
+    }
+    int g = exgcd(b, a % b, y, x);
+    *y -= (a / b) * (*x);
+    return g;
+}

benchmarks/Algorithms/gcd/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "gcd",
+  "source": {
+    "dataset": "classical_algorithm",
+    "problem_id": "gcd",
+    "title": "Euclidean Greatest Common Divisor",
+    "tags": [
+      "gcd",
+      "euclid",
+      "recursion"
+    ]
+  },
+  "stratification": {
+    "band": "unclassified",
+    "output_mode": "COUNTOPT",
+    "interactive": false,
+    "multi_test": false
+  }
+}

benchmarks/Algorithms/gcd/problem.md

@@ -0,0 +1,13 @@
+# Euclidean Greatest Common Divisor
+
+## Description
+
+Compute the greatest common divisor of two integers with the recursive Euclidean algorithm.
+
+## Input
+
+The function receives two integers $x$ and $y$ ($-2^{31} < x, y \le 2^{31} - 1$).
+
+## Output
+
+Return $\gcd(x, y)$, the non-negative greatest common divisor, with $\gcd(x, 0) = |x|$.

benchmarks/Algorithms/gcd/rocq/groundtruth/gcd_goal.v

@@ -0,0 +1,241 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Local Open Scope sac.
+
+(*----- Function abs -----*)
+
+Definition abs_safety_wit_1 := 
+forall (x_pre: Z) (PreH1 : (INT_MIN < x_pre)) (PreH2 : (x_pre <= INT_MAX)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition abs_safety_wit_2 := 
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+|--
+  “ (x_pre <> (INT_MIN)) ”
+.
+
+Definition abs_return_wit_1 := 
+(
+forall (x_pre: Z) (PreH1 : (x_pre >= 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ (x_pre = (Zabs (x_pre))) ”
+  &&  emp
+) \/
+(
+forall (x_pre: Z) (PreH1 : (x_pre >= 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ (x_pre = (Zabs (x_pre))) ”
+  &&  emp
+).
+
+Definition abs_return_wit_1_split_goal_1 := 
+forall (x_pre: Z) (PreH1 : (x_pre >= 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  (x_pre = (Zabs (x_pre)))
+.
+
+Definition abs_return_wit_2 := 
+(
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((-x_pre) = (Zabs (x_pre))) ”
+  &&  emp
+) \/
+(
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  TT && emp 
+|--
+  “ ((-x_pre) = (Zabs (x_pre))) ”
+  &&  emp
+).
+
+Definition abs_return_wit_2_split_goal_1 := 
+forall (x_pre: Z) (PreH1 : (x_pre < 0)) (PreH2 : (INT_MIN < x_pre)) (PreH3 : (x_pre <= INT_MAX)) ,
+  ((-x_pre) = (Zabs (x_pre)))
+.
+
+(*----- Function gcd -----*)
+
+Definition gcd_safety_wit_1 := 
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (x_pre <= INT_MAX)) (PreH2 : (y_pre <= INT_MAX)) (PreH3 : (y_pre >= INT_MIN)) (PreH4 : (INT_MIN < x_pre)) (PreH5 : (INT_MIN < y_pre)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition gcd_safety_wit_2 := 
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (y_pre <> 0)) (PreH2 : (x_pre <= INT_MAX)) (PreH3 : (y_pre <= INT_MAX)) (PreH4 : (y_pre >= INT_MIN)) (PreH5 : (INT_MIN < x_pre)) (PreH6 : (INT_MIN < y_pre)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+|--
+  “ ((x_pre <> (INT_MIN)) \/ (y_pre <> (-1))) ” 
+  &&  “ (y_pre <> 0) ”
+.
+
+Definition gcd_entail_wit_1 := 
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (INT_MIN < x_pre)) (PreH2 : (INT_MIN < y_pre)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+|--
+  “ (x_pre <= INT_MAX) ” 
+  &&  “ (y_pre <= INT_MAX) ” 
+  &&  “ (y_pre >= INT_MIN) ” 
+  &&  “ (INT_MIN < x_pre) ” 
+  &&  “ (INT_MIN < y_pre) ”
+  &&  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+.
+
+Definition gcd_return_wit_1 := 
+(
+forall (y_pre: Z) (x_pre: Z) (retval: Z) (PreH1 : (retval = (Zgcd (y_pre) ((x_pre % ( y_pre ) ))))) (PreH2 : (y_pre <> 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  TT && emp 
+|--
+  “ (retval = (Zgcd (x_pre) (y_pre))) ”
+  &&  emp
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (retval: Z) (PreH1 : (retval = (Zgcd (y_pre) ((x_pre % ( y_pre ) ))))) (PreH2 : (y_pre <> 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  TT && emp 
+|--
+  “ (retval = (Zgcd (x_pre) (y_pre))) ”
+  &&  emp
+).
+
+Definition gcd_return_wit_1_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (retval: Z) (PreH1 : (retval = (Zgcd (y_pre) ((x_pre % ( y_pre ) ))))) (PreH2 : (y_pre <> 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  (retval = (Zgcd (x_pre) (y_pre)))
+.
+
+Definition gcd_return_wit_2 := 
+(
+forall (y_pre: Z) (x_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (x_pre)))) (PreH2 : (y_pre = 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  TT && emp 
+|--
+  “ (retval = (Zgcd (x_pre) (y_pre))) ”
+  &&  emp
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (x_pre)))) (PreH2 : (y_pre = 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  TT && emp 
+|--
+  “ (retval = (Zgcd (x_pre) (0))) ”
+  &&  emp
+).
+
+Definition gcd_return_wit_2_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (retval: Z) (PreH1 : (retval = (Zabs (x_pre)))) (PreH2 : (y_pre = 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  (retval = (Zgcd (x_pre) (0)))
+.
+
+Definition gcd_partial_solve_wit_1_pure := 
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (y_pre = 0)) (PreH2 : (x_pre <= INT_MAX)) (PreH3 : (y_pre <= INT_MAX)) (PreH4 : (y_pre >= INT_MIN)) (PreH5 : (INT_MIN < x_pre)) (PreH6 : (INT_MIN < y_pre)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+|--
+  “ (INT_MIN < x_pre) ” 
+  &&  “ (x_pre <= INT_MAX) ”
+.
+
+Definition gcd_partial_solve_wit_1_aux := 
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (y_pre = 0)) (PreH2 : (x_pre <= INT_MAX)) (PreH3 : (y_pre <= INT_MAX)) (PreH4 : (y_pre >= INT_MIN)) (PreH5 : (INT_MIN < x_pre)) (PreH6 : (INT_MIN < y_pre)) ,
+  TT && emp 
+|--
+  “ (INT_MIN < x_pre) ” 
+  &&  “ (x_pre <= INT_MAX) ” 
+  &&  “ (y_pre = 0) ” 
+  &&  “ (x_pre <= INT_MAX) ” 
+  &&  “ (y_pre <= INT_MAX) ” 
+  &&  “ (y_pre >= INT_MIN) ” 
+  &&  “ (INT_MIN < x_pre) ” 
+  &&  “ (INT_MIN < y_pre) ”
+  &&  emp
+.
+
+Definition gcd_partial_solve_wit_1 := gcd_partial_solve_wit_1_pure -> gcd_partial_solve_wit_1_aux.
+
+Definition gcd_partial_solve_wit_2_pure := 
+(
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (y_pre <> 0)) (PreH2 : (x_pre <= INT_MAX)) (PreH3 : (y_pre <= INT_MAX)) (PreH4 : (y_pre >= INT_MIN)) (PreH5 : (INT_MIN < x_pre)) (PreH6 : (INT_MIN < y_pre)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+|--
+  “ (INT_MIN < y_pre) ” 
+  &&  “ (INT_MIN < (x_pre % ( y_pre ) )) ”
+) \/
+(
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (x_pre >= INT_MIN)) (PreH2 : (y_pre <> 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+|--
+  “ (INT_MIN < (x_pre % ( y_pre ) )) ”
+).
+
+Definition gcd_partial_solve_wit_2_pure_split_goal_1 := 
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (x_pre >= INT_MIN)) (PreH2 : (y_pre <> 0)) (PreH3 : (x_pre <= INT_MAX)) (PreH4 : (y_pre <= INT_MAX)) (PreH5 : (y_pre >= INT_MIN)) (PreH6 : (INT_MIN < x_pre)) (PreH7 : (INT_MIN < y_pre)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "y" ) )) # Int  |-> y_pre)
+|--
+  “ (INT_MIN < (x_pre % ( y_pre ) )) ”
+.
+
+Definition gcd_partial_solve_wit_2_aux := 
+forall (y_pre: Z) (x_pre: Z) (PreH1 : (y_pre <> 0)) (PreH2 : (x_pre <= INT_MAX)) (PreH3 : (y_pre <= INT_MAX)) (PreH4 : (y_pre >= INT_MIN)) (PreH5 : (INT_MIN < x_pre)) (PreH6 : (INT_MIN < y_pre)) ,
+  TT && emp 
+|--
+  “ (INT_MIN < y_pre) ” 
+  &&  “ (INT_MIN < (x_pre % ( y_pre ) )) ” 
+  &&  “ (y_pre <> 0) ” 
+  &&  “ (x_pre <= INT_MAX) ” 
+  &&  “ (y_pre <= INT_MAX) ” 
+  &&  “ (y_pre >= INT_MIN) ” 
+  &&  “ (INT_MIN < x_pre) ” 
+  &&  “ (INT_MIN < y_pre) ”
+  &&  emp
+.
+
+Definition gcd_partial_solve_wit_2 := gcd_partial_solve_wit_2_pure -> gcd_partial_solve_wit_2_aux.
+
+Module Type VC_Correct.
+
+
+Axiom proof_of_abs_safety_wit_1 : abs_safety_wit_1.
+Axiom proof_of_abs_safety_wit_2 : abs_safety_wit_2.
+Axiom proof_of_abs_return_wit_1 : abs_return_wit_1.
+Axiom proof_of_abs_return_wit_2 : abs_return_wit_2.
+Axiom proof_of_gcd_safety_wit_1 : gcd_safety_wit_1.
+Axiom proof_of_gcd_safety_wit_2 : gcd_safety_wit_2.
+Axiom proof_of_gcd_entail_wit_1 : gcd_entail_wit_1.
+Axiom proof_of_gcd_return_wit_1 : gcd_return_wit_1.
+Axiom proof_of_gcd_return_wit_2 : gcd_return_wit_2.
+Axiom proof_of_gcd_partial_solve_wit_1_pure : gcd_partial_solve_wit_1_pure.
+Axiom proof_of_gcd_partial_solve_wit_1 : gcd_partial_solve_wit_1.
+Axiom proof_of_gcd_partial_solve_wit_2_pure : gcd_partial_solve_wit_2_pure.
+Axiom proof_of_gcd_partial_solve_wit_2 : gcd_partial_solve_wit_2.
+
+End VC_Correct.

benchmarks/Algorithms/gcd/rocq/groundtruth/gcd_goal_check.v

@@ -0,0 +1,6 @@
+From PVbench.Algorithms.gcd.rocq.groundtruth Require Import gcd_goal gcd_proof_auto gcd_proof_manual.
+
+Module VC_Correctness : VC_Correct.
+  Include gcd_proof_auto.
+  Include gcd_proof_manual.
+End VC_Correctness.

benchmarks/Algorithms/gcd/rocq/groundtruth/gcd_proof_auto.v

@@ -0,0 +1,45 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.gcd.rocq.groundtruth Require Import gcd_goal.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Local Open Scope sac.
+
+Lemma proof_of_abs_safety_wit_1 : abs_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_abs_safety_wit_2 : abs_safety_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_gcd_safety_wit_1 : gcd_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_gcd_safety_wit_2 : gcd_safety_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_gcd_entail_wit_1 : gcd_entail_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_gcd_partial_solve_wit_1_pure : gcd_partial_solve_wit_1_pure.
+Proof. Admitted. 
+
+Lemma proof_of_gcd_partial_solve_wit_1 : gcd_partial_solve_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_gcd_partial_solve_wit_2 : gcd_partial_solve_wit_2.
+Proof. Admitted. 
+

benchmarks/Algorithms/gcd/rocq/groundtruth/gcd_proof_manual.v

@@ -0,0 +1,95 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.gcd.rocq.groundtruth Require Import gcd_goal.
+From PVbench.Algorithms.gcd.rocq.groundtruth Require Import gcd_proof_auto.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import PVbench.Algorithms.gcd.rocq.groundtruth.proof_lib.
+Local Open Scope sac.
+
+Lemma proof_of_gcd_return_wit_1_split_goal_1 : gcd_return_wit_1_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  subst.
+  pose proof Z.gcd_rem x_pre y_pre ltac:(lia).
+  rewrite Z.gcd_comm, H, Z.gcd_comm.
+  reflexivity.
+Qed.
+
+Lemma proof_of_gcd_return_wit_1 : gcd_return_wit_1.
+Proof.
+  aggressive_pre_process.
+  Goal_apply proof_of_gcd_return_wit_1_split_goal_1.
+Qed.
+
+Lemma proof_of_gcd_return_wit_2_split_goal_1 : gcd_return_wit_2_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  subst.
+  rewrite Z.gcd_0_r.
+  reflexivity.
+Qed.
+
+Lemma proof_of_gcd_return_wit_2 : gcd_return_wit_2.
+Proof.
+  aggressive_pre_process.
+  Goal_apply proof_of_gcd_return_wit_2_split_goal_1.
+Qed.
+
+Lemma proof_of_gcd_partial_solve_wit_2_pure_split_goal_1 : gcd_partial_solve_wit_2_pure_split_goal_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  prop_apply (store_int_range (&("y")) y_pre).
+  Intros.
+  change (Int.min_signed) with (-2147483648) in H.
+  change (Int.max_signed) with (2147483647) in H.
+  pose proof Z.rem_bound_pos_pos x_pre y_pre.
+  pose proof Z.rem_bound_neg_pos x_pre y_pre.
+  pose proof Z.rem_bound_pos_neg x_pre y_pre.
+  pose proof Z.rem_bound_neg_neg x_pre y_pre.
+  repeat (split_pure_spatial || split_pures); try cancel; dump_pre_spatial; lia.
+Qed.
+
+Lemma proof_of_gcd_partial_solve_wit_2_pure : gcd_partial_solve_wit_2_pure.
+Proof.
+  aggressive_pre_process.
+  Goal_apply proof_of_gcd_partial_solve_wit_2_pure_split_goal_1.
+Qed.
+
+Lemma proof_of_abs_return_wit_1_split_goal_1 : abs_return_wit_1_split_goal_1.
+Proof.
+  unfold abs_return_wit_1_split_goal_1; intros.
+  lia.
+Qed.
+
+Lemma proof_of_abs_return_wit_1 : abs_return_wit_1.
+Proof.
+  aggressive_pre_process.
+  Goal_apply proof_of_abs_return_wit_1_split_goal_1.
+Qed.
+
+Lemma proof_of_abs_return_wit_2_split_goal_1 : abs_return_wit_2_split_goal_1.
+Proof.
+  unfold abs_return_wit_2_split_goal_1; intros.
+  lia.
+Qed.
+
+Lemma proof_of_abs_return_wit_2 : abs_return_wit_2.
+Proof.
+  aggressive_pre_process.
+  Goal_apply proof_of_abs_return_wit_2_split_goal_1.
+Qed.

benchmarks/Algorithms/gcd/rocq/groundtruth/proof_lib.v

@@ -0,0 +1,2 @@
+(* gcd needs no supporting lemmas: Coq's Z.gcd library closes every goal. *)
+From Coq Require Import ZArith.

benchmarks/Algorithms/gcd/rocq/solution_annotated.c

@@ -0,0 +1,32 @@
+/*@ Extern Coq (Zgcd: Z -> Z -> Z)
+               (Zabs: Z -> Z) */
+
+int abs(int x)
+/*@ Require
+      INT_MIN < x && x <= INT_MAX && emp
+    Ensure
+      __return == Zabs(x) && emp
+*/
+{
+  if (x < 0) {
+    return -x;
+  }
+  return x;
+}
+
+int gcd(int x, int y)
+/*@ Require
+      INT_MIN < x && INT_MIN < y
+    Ensure
+      __return == Zgcd(x, y)
+*/
+{
+  /*@ x <= INT_MAX by local */
+  if (y == 0)
+  {
+    return abs(x);
+  }
+  else {
+    return gcd(y, x % y);
+  }
+}

benchmarks/Algorithms/gcd/rocq/solution_spec.c

@@ -0,0 +1,25 @@
+/*@ Extern Coq (Zgcd: Z -> Z -> Z) */
+
+int abs(int x)
+{
+  if (x < 0) {
+    return -x;
+  }
+  return x;
+}
+
+int gcd(int x, int y)
+/*@ Require
+      INT_MIN < x && INT_MIN < y
+    Ensure
+      __return == Zgcd(x, y)
+*/
+{
+  if (y == 0)
+  {
+    return abs(x);
+  }
+  else {
+    return gcd(y, x % y);
+  }
+}

benchmarks/Algorithms/gcd/solution.c

@@ -0,0 +1,18 @@
+int abs(int x)
+{
+  if (x < 0) {
+    return -x;
+  }
+  return x;
+}
+
+int gcd(int x, int y)
+{
+  if (y == 0)
+  {
+    return abs(x);
+  }
+  else {
+    return gcd(y, x % y);
+  }
+}

benchmarks/Algorithms/sll_insertion_sort/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "sll_insertion_sort",
+  "source": {
+    "dataset": "classical_algorithm",
+    "problem_id": "sll_insertion_sort",
+    "title": "Insertion Sort on a Singly Linked List",
+    "tags": [
+      "sort",
+      "insertion",
+      "linked list"
+    ]
+  },
+  "stratification": {
+    "band": "unclassified",
+    "output_mode": "CONSTRUCT",
+    "interactive": false,
+    "multi_test": false
+  }
+}

benchmarks/Algorithms/sll_insertion_sort/problem.md

@@ -0,0 +1,22 @@
+# Insertion Sort on a Singly Linked List
+
+## Description
+
+Sort a null-terminated singly linked list of integers into nondecreasing order using insertion sort, relinking the existing nodes.
+
+## Input
+
+A list is given by a pointer to its first node, or `NULL` when empty:
+
+```c
+struct list {
+   int data;
+   struct list *next;
+};
+```
+
+The function receives the head `x` of the list.
+
+## Output
+
+Return the head of a list holding the same values in nondecreasing order.

benchmarks/Algorithms/sll_insertion_sort/rocq/groundtruth/proof_lib.v

@@ -0,0 +1,105 @@
+(* Supporting lemmas for the manual proof. *)
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import SimpleC.EE.QCP_demos_LLM.sll_lib.
+Require Import PVbench.Algorithms.sll_insertion_sort.rocq.helper_lib.
+Local Open Scope sac.
+Import ListNotations.
+Local Open Scope list.
+
+Lemma upperbound_insert_nil:
+  forall x l,
+    strict_upperbound x l ->
+    insert x l = l ++ [x].
+Proof.
+  intros. 
+  induction l; simpl; try easy.
+  simpl in H. destruct H.
+  destruct (x >? a) eqn:b; simpl; try lia.
+  apply IHl in H0. rewrite H0. reflexivity.
+Qed.
+
+Lemma upperbound_insert_cons:
+  forall x l1 l2 y,
+    strict_upperbound x l1 ->
+    x <= y ->
+    insert x (l1 ++ y :: l2) = l1 ++ x :: y :: l2.
+Proof.
+  intros. 
+  induction l1; simpl; try easy; simpl in H.
+  - destruct (x >? y) eqn:b; simpl; [lia | easy].
+  - destruct H. destruct (x >? a) eqn:b; simpl; try lia.
+    apply IHl1 in H1. rewrite H1. reflexivity.
+Qed.
+
+Lemma increasing_aux_insert:
+  forall x l a,
+    increasing_aux l a ->
+    a <= x ->
+    increasing_aux (insert x l) a.
+Proof.
+  intros. revert a H H0.  
+  induction l; intros; simpl; try easy.
+  simpl in H. 
+  destruct (x >? a) eqn:b; simpl.
+  - split; try easy.
+    apply IHl; [easy | lia].
+  - repeat split; try easy. lia.
+Qed.
+
+Lemma increasing_insert:
+  forall x l,
+    increasing l ->
+    increasing (insert x l).
+Proof.
+  intros. destruct l; simpl; try easy.
+  simpl in H.
+  destruct (x >? z) eqn:b; simpl.
+  - apply increasing_aux_insert; [easy | lia]. 
+  - split; [lia | easy]. 
+Qed.
+
+Lemma perm_insert:
+  forall x l,
+    Permutation (l ++ [x]) (insert x l).
+Proof.
+  intros. induction l; simpl; try easy.
+  destruct (x >? a).
+  - rewrite IHl. reflexivity.
+  - rewrite <- Permutation_cons_append. apply perm_swap.
+Qed.
+
+
+Lemma upperbound_insert_app:
+  forall x l1 l2,
+    strict_upperbound x l1 ->
+    insert x (l1 ++ l2) = l1 ++ insert x l2.
+Proof.
+  intros x l1 l2 Hupper.
+  revert l2 Hupper.
+  induction l1; intros l2 Hupper.
+  - reflexivity.
+  - simpl in Hupper.
+    destruct Hupper.
+    simpl.
+    destruct (x >? a) eqn:Hgt.
+    + f_equal.
+      apply IHl1.
+      exact H0.
+    + lia.
+Qed.

benchmarks/Algorithms/sll_insertion_sort/rocq/groundtruth/sll_insertion_sort_goal.v

@@ -0,0 +1,506 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import SimpleC.EE.QCP_demos_LLM.sll_lib.
+Require Import PVbench.Algorithms.sll_insertion_sort.rocq.helper_lib.
+Local Open Scope sac.
+From SimpleC.EE.QCP_demos_LLM Require Import sll_strategy_goal.
+From SimpleC.EE.QCP_demos_LLM Require Import sll_strategy_proof.
+
+(*----- Function insertion -----*)
+
+Definition insertion_safety_wit_1 := 
+forall (node_pre: Z) (p_pre: Z) (a: Z) (l: (@list Z)) (p2_v: Z) (p2: Z) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (node_pre <> 0)) (PreH2 : (l = (app (l1) (l2)))) (PreH3 : (strict_upperbound a l1 )) ,
+  ((( &( "node" ) )) # Ptr  |-> node_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p_pre)
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((( &( "p2" ) )) # Ptr  |-> p2)
+  **  (sllbseg ( &( "res" ) ) p2 l1 )
+  **  ((p2) # Ptr  |-> p2_v)
+  **  (sll p2_v l2 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition insertion_entail_wit_1 := 
+(
+forall (node_pre: Z) (p_pre: Z) (a: Z) (l: (@list Z)) (PreH1 : (node_pre <> 0)) ,
+  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sll p_pre l )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+|--
+  EX (l1: (@list Z))  (l2: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) (l2))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) ( &( "res" ) ) l1 )
+  **  (sll p_pre l2 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+) \/
+(
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (PreH1 : (node_pre <> 0)) ,
+  TT && emp 
+|--
+  EX (l1: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) (l))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  (sllbseg ( &( "res" ) ) ( &( "res" ) ) l1 )
+).
+
+Definition insertion_entail_wit_2 := 
+(
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (p2_v_2: Z) (p2: Z) (l1_2: (@list Z)) (l2_2: (@list Z)) (x: Z) (l0: (@list Z)) (y: Z) (PreH1 : (x < a)) (PreH2 : (l2_2 = (cons (x) (l0)))) (PreH3 : (p2_v_2 <> 0)) (PreH4 : (node_pre <> 0)) (PreH5 : (l = (app (l1_2) (l2_2)))) (PreH6 : (strict_upperbound a l1_2 )) ,
+  ((&((p2_v_2)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  (sll y l0 )
+  **  ((&((p2_v_2)  # "list" ->ₛ "next")) # Ptr  |-> y)
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1_2 )
+  **  ((p2) # Ptr  |-> p2_v_2)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+|--
+  EX (p2_v: Z)  (l1: (@list Z))  (l2: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) (l2))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) &((p2_v_2)  # "list" ->ₛ "next") l1 )
+  **  ((&((p2_v_2)  # "list" ->ₛ "next")) # Ptr  |-> p2_v)
+  **  (sll p2_v l2 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+) \/
+(
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (p2_v_2: Z) (p2: Z) (l1_2: (@list Z)) (l2_2: (@list Z)) (x: Z) (l0: (@list Z)) (PreH1 : (x <= INT_MAX)) (PreH2 : (x >= INT_MIN)) (PreH3 : (x < a)) (PreH4 : (l2_2 = (cons (x) (l0)))) (PreH5 : (p2_v_2 <> 0)) (PreH6 : (node_pre <> 0)) (PreH7 : (l = (app (l1_2) (l2_2)))) (PreH8 : (strict_upperbound a l1_2 )) ,
+  ((&((p2_v_2)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  (sllbseg ( &( "res" ) ) p2 l1_2 )
+  **  ((p2) # Ptr  |-> p2_v_2)
+|--
+  EX (l1: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) (l0))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  (sllbseg ( &( "res" ) ) &((p2_v_2)  # "list" ->ₛ "next") l1 )
+).
+
+Definition insertion_entail_wit_3_1 := 
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (p2_v: Z) (p2: Z) (l1_3: (@list Z)) (l2: (@list Z)) (PreH1 : (p2_v = 0)) (PreH2 : (node_pre <> 0)) (PreH3 : (l = (app (l1_3) (l2)))) (PreH4 : (strict_upperbound a l1_3 )) ,
+  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1_3 )
+  **  ((p2) # Ptr  |-> p2_v)
+  **  (sll p2_v l2 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+|--
+  (EX (l1: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) ((@nil Z)))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1 )
+  **  ((p2) # Ptr  |-> 0)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_))
+  ||
+  (EX (unext: Z)  (l1_2: (@list Z))  (l0: (@list Z))  (x: Z)  (u: Z) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (u <> 0) ” 
+  &&  “ (x >= a) ” 
+  &&  “ (l = (app (l1_2) ((cons (x) (l0))))) ” 
+  &&  “ (strict_upperbound a l1_2 ) ”
+  &&  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1_2 )
+  **  ((p2) # Ptr  |-> u)
+  **  ((&((u)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((u)  # "list" ->ₛ "next")) # Ptr  |-> unext)
+  **  (sll unext l0 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_))
+.
+
+Definition insertion_entail_wit_3_2 := 
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (p2_v: Z) (p2: Z) (l1_3: (@list Z)) (l2: (@list Z)) (x_2: Z) (l0_2: (@list Z)) (y: Z) (PreH1 : (x_2 >= a)) (PreH2 : (l2 = (cons (x_2) (l0_2)))) (PreH3 : (p2_v <> 0)) (PreH4 : (node_pre <> 0)) (PreH5 : (l = (app (l1_3) (l2)))) (PreH6 : (strict_upperbound a l1_3 )) ,
+  ((&((p2_v)  # "list" ->ₛ "data")) # Int  |-> x_2)
+  **  (sll y l0_2 )
+  **  ((&((p2_v)  # "list" ->ₛ "next")) # Ptr  |-> y)
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1_3 )
+  **  ((p2) # Ptr  |-> p2_v)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+|--
+  (EX (l1: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) ((@nil Z)))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1 )
+  **  ((p2) # Ptr  |-> 0)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_))
+  ||
+  (EX (unext: Z)  (l1_2: (@list Z))  (l0: (@list Z))  (x: Z)  (u: Z) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (u <> 0) ” 
+  &&  “ (x >= a) ” 
+  &&  “ (l = (app (l1_2) ((cons (x) (l0))))) ” 
+  &&  “ (strict_upperbound a l1_2 ) ”
+  &&  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1_2 )
+  **  ((p2) # Ptr  |-> u)
+  **  ((&((u)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((u)  # "list" ->ₛ "next")) # Ptr  |-> unext)
+  **  (sll unext l0 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_))
+.
+
+Definition insertion_entail_wit_4_1 := 
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (l1_3: (@list Z)) (p2: Z) (PreH1 : (node_pre <> 0)) (PreH2 : (l = (app (l1_3) ((@nil Z))))) (PreH3 : (strict_upperbound a l1_3 )) ,
+  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1_3 )
+  **  ((p2) # Ptr  |-> node_pre)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+|--
+  (EX (resv: Z)  (l1: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) ((@nil Z)))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  ((( &( "res" ) )) # Ptr  |-> resv)
+  **  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> 0))
+  ||
+  (EX (unext: Z)  (resv_2: Z)  (l1_2: (@list Z))  (l0: (@list Z))  (x: Z)  (u: Z) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (u <> 0) ” 
+  &&  “ (x >= a) ” 
+  &&  “ (l = (app (l1_2) ((cons (x) (l0))))) ” 
+  &&  “ (strict_upperbound a l1_2 ) ”
+  &&  ((( &( "res" ) )) # Ptr  |-> resv_2)
+  **  (sllseg resv_2 node_pre l1_2 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> u)
+  **  ((&((u)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((u)  # "list" ->ₛ "next")) # Ptr  |-> unext)
+  **  (sll unext l0 ))
+.
+
+Definition insertion_entail_wit_4_2 := 
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (l1_3: (@list Z)) (x_2: Z) (l0_2: (@list Z)) (u_2: Z) (unext_2: Z) (p2: Z) (PreH1 : (node_pre <> 0)) (PreH2 : (u_2 <> 0)) (PreH3 : (x_2 >= a)) (PreH4 : (l = (app (l1_3) ((cons (x_2) (l0_2)))))) (PreH5 : (strict_upperbound a l1_3 )) ,
+  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1_3 )
+  **  ((p2) # Ptr  |-> node_pre)
+  **  ((&((u_2)  # "list" ->ₛ "data")) # Int  |-> x_2)
+  **  ((&((u_2)  # "list" ->ₛ "next")) # Ptr  |-> unext_2)
+  **  (sll unext_2 l0_2 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> u_2)
+|--
+  (EX (resv: Z)  (l1: (@list Z)) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) ((@nil Z)))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  ((( &( "res" ) )) # Ptr  |-> resv)
+  **  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> 0))
+  ||
+  (EX (unext: Z)  (resv_2: Z)  (l1_2: (@list Z))  (l0: (@list Z))  (x: Z)  (u: Z) ,
+  “ (node_pre <> 0) ” 
+  &&  “ (u <> 0) ” 
+  &&  “ (x >= a) ” 
+  &&  “ (l = (app (l1_2) ((cons (x) (l0))))) ” 
+  &&  “ (strict_upperbound a l1_2 ) ”
+  &&  ((( &( "res" ) )) # Ptr  |-> resv_2)
+  **  (sllseg resv_2 node_pre l1_2 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> u)
+  **  ((&((u)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((u)  # "list" ->ₛ "next")) # Ptr  |-> unext)
+  **  (sll unext l0 ))
+.
+
+Definition insertion_return_wit_1 := 
+(
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (resv: Z) (l1: (@list Z)) (PreH1 : (node_pre <> 0)) (PreH2 : (l = (app (l1) ((@nil Z))))) (PreH3 : (strict_upperbound a l1 )) ,
+  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+|--
+  EX (l0: (@list Z)) ,
+  “ (l0 = (insert (a) (l))) ”
+  &&  (sll resv l0 )
+) \/
+(
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (resv: Z) (l1: (@list Z)) (PreH1 : (a <= INT_MAX)) (PreH2 : (a >= INT_MIN)) (PreH3 : (node_pre <> 0)) (PreH4 : (l = (app (l1) ((@nil Z))))) (PreH5 : (strict_upperbound a l1 )) ,
+  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+|--
+  (sll resv (insert (a) (l)) )
+).
+
+Definition insertion_return_wit_1_split_goal_spatial := 
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (resv: Z) (l1: (@list Z)) (PreH1 : (a <= INT_MAX)) (PreH2 : (a >= INT_MIN)) (PreH3 : (node_pre <> 0)) (PreH4 : (l = (app (l1) ((@nil Z))))) (PreH5 : (strict_upperbound a l1 )) ,
+  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+|--
+  (sll resv (insert (a) (l)) )
+.
+
+Definition insertion_return_wit_2 := 
+(
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (resv: Z) (l1: (@list Z)) (x: Z) (l0_2: (@list Z)) (u: Z) (unext: Z) (PreH1 : (node_pre <> 0)) (PreH2 : (u <> 0)) (PreH3 : (x >= a)) (PreH4 : (l = (app (l1) ((cons (x) (l0_2)))))) (PreH5 : (strict_upperbound a l1 )) ,
+  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> u)
+  **  ((&((u)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((u)  # "list" ->ₛ "next")) # Ptr  |-> unext)
+  **  (sll unext l0_2 )
+|--
+  EX (l0: (@list Z)) ,
+  “ (l0 = (insert (a) (l))) ”
+  &&  (sll resv l0 )
+) \/
+(
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (resv: Z) (l1: (@list Z)) (x: Z) (l0_2: (@list Z)) (u: Z) (unext: Z) (PreH1 : (x <= INT_MAX)) (PreH2 : (a <= INT_MAX)) (PreH3 : (x >= INT_MIN)) (PreH4 : (a >= INT_MIN)) (PreH5 : (node_pre <> 0)) (PreH6 : (u <> 0)) (PreH7 : (x >= a)) (PreH8 : (l = (app (l1) ((cons (x) (l0_2)))))) (PreH9 : (strict_upperbound a l1 )) ,
+  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> u)
+  **  ((&((u)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((u)  # "list" ->ₛ "next")) # Ptr  |-> unext)
+  **  (sll unext l0_2 )
+|--
+  (sll resv (insert (a) (l)) )
+).
+
+Definition insertion_return_wit_2_split_goal_spatial := 
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (resv: Z) (l1: (@list Z)) (x: Z) (l0_2: (@list Z)) (u: Z) (unext: Z) (PreH1 : (x <= INT_MAX)) (PreH2 : (a <= INT_MAX)) (PreH3 : (x >= INT_MIN)) (PreH4 : (a >= INT_MIN)) (PreH5 : (node_pre <> 0)) (PreH6 : (u <> 0)) (PreH7 : (x >= a)) (PreH8 : (l = (app (l1) ((cons (x) (l0_2)))))) (PreH9 : (strict_upperbound a l1 )) ,
+  (sllseg resv node_pre l1 )
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |-> u)
+  **  ((&((u)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((u)  # "list" ->ₛ "next")) # Ptr  |-> unext)
+  **  (sll unext l0_2 )
+|--
+  (sll resv (insert (a) (l)) )
+.
+
+Definition insertion_partial_solve_wit_1 := 
+forall (node_pre: Z) (a: Z) (l: (@list Z)) (p2_v: Z) (p2: Z) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (p2_v <> 0)) (PreH2 : (node_pre <> 0)) (PreH3 : (l = (app (l1) (l2)))) (PreH4 : (strict_upperbound a l1 )) ,
+  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1 )
+  **  ((p2) # Ptr  |-> p2_v)
+  **  (sll p2_v l2 )
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+|--
+  EX (x: Z)  (l0: (@list Z))  (y: Z) ,
+  “ (l2 = (cons (x) (l0))) ” 
+  &&  “ (p2_v <> 0) ” 
+  &&  “ (node_pre <> 0) ” 
+  &&  “ (l = (app (l1) (l2))) ” 
+  &&  “ (strict_upperbound a l1 ) ”
+  &&  ((&((p2_v)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  (sll y l0 )
+  **  ((&((p2_v)  # "list" ->ₛ "next")) # Ptr  |-> y)
+  **  ((&((node_pre)  # "list" ->ₛ "data")) # Int  |-> a)
+  **  (sllbseg ( &( "res" ) ) p2 l1 )
+  **  ((p2) # Ptr  |-> p2_v)
+  **  ((&((node_pre)  # "list" ->ₛ "next")) # Ptr  |->_)
+.
+
+(*----- Function insertion_sort -----*)
+
+Definition insertion_sort_safety_wit_1 := 
+forall (x_pre: Z) (l: (@list Z)) ,
+  ((( &( "res" ) )) # Ptr  |->_)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  (sll x_pre l )
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition insertion_sort_safety_wit_2 := 
+forall (x_pre: Z) (l: (@list Z)) (p: Z) (res: Z) (l0: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (l = (app (l1) (l2)))) (PreH2 : (Permutation l1 l0 )) (PreH3 : (increasing l0 )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "q" ) )) # Ptr  |->_)
+  **  ((( &( "res" ) )) # Ptr  |-> res)
+  **  (sll res l0 )
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  (sll p l2 )
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition insertion_sort_entail_wit_1 := 
+(
+forall (x_pre: Z) (l: (@list Z)) ,
+  (sll x_pre l )
+|--
+  EX (l0: (@list Z))  (l1: (@list Z))  (l2: (@list Z)) ,
+  “ (l = (app (l1) (l2))) ” 
+  &&  “ (Permutation l1 l0 ) ” 
+  &&  “ (increasing l0 ) ”
+  &&  (sll 0 l0 )
+  **  (sll x_pre l2 )
+) \/
+(
+forall (l: (@list Z)) ,
+  TT && emp 
+|--
+  EX (l1: (@list Z)) ,
+  “ (l = (app (l1) (l))) ” 
+  &&  “ (Permutation l1 (@nil Z) ) ” 
+  &&  “ (increasing (@nil Z) ) ”
+  &&  emp
+).
+
+Definition insertion_sort_entail_wit_2 := 
+(
+forall (l: (@list Z)) (p: Z) (l0_2: (@list Z)) (l1_2: (@list Z)) (l2_2: (@list Z)) (x: Z) (l0_3: (@list Z)) (y: Z) (l0_4: (@list Z)) (retval: Z) (PreH1 : (l0_4 = (insert (x) (l0_2)))) (PreH2 : (l2_2 = (cons (x) (l0_3)))) (PreH3 : (p <> 0)) (PreH4 : (l = (app (l1_2) (l2_2)))) (PreH5 : (Permutation l1_2 l0_2 )) (PreH6 : (increasing l0_2 )) ,
+  (sll retval l0_4 )
+  **  (sll y l0_3 )
+  **  ((( &( "q" ) )) # Ptr  |-> y)
+|--
+  EX (l0: (@list Z))  (l1: (@list Z))  (l2: (@list Z)) ,
+  “ (l = (app (l1) (l2))) ” 
+  &&  “ (Permutation l1 l0 ) ” 
+  &&  “ (increasing l0 ) ”
+  &&  ((( &( "q" ) )) # Ptr  |->_)
+  **  (sll retval l0 )
+  **  (sll y l2 )
+) \/
+(
+forall (l: (@list Z)) (p: Z) (l0_2: (@list Z)) (l1_2: (@list Z)) (l2_2: (@list Z)) (x: Z) (l0_3: (@list Z)) (l0_4: (@list Z)) (PreH1 : (l0_4 = (insert (x) (l0_2)))) (PreH2 : (l2_2 = (cons (x) (l0_3)))) (PreH3 : (p <> 0)) (PreH4 : (l = (app (l1_2) (l2_2)))) (PreH5 : (Permutation l1_2 l0_2 )) (PreH6 : (increasing l0_2 )) ,
+  TT && emp 
+|--
+  EX (l1: (@list Z)) ,
+  “ ((app (l1_2) (l2_2)) = (app (l1) (l0_3))) ” 
+  &&  “ (Permutation l1 (insert (x) (l0_2)) ) ” 
+  &&  “ (increasing (insert (x) (l0_2)) ) ”
+  &&  emp
+).
+
+Definition insertion_sort_return_wit_1 := 
+(
+forall (l: (@list Z)) (p: Z) (res: Z) (l0_2: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (p = 0)) (PreH2 : (l = (app (l1) (l2)))) (PreH3 : (Permutation l1 l0_2 )) (PreH4 : (increasing l0_2 )) ,
+  (sll res l0_2 )
+  **  (sll p l2 )
+|--
+  EX (l0: (@list Z)) ,
+  “ (Permutation l l0 ) ” 
+  &&  “ (increasing l0 ) ”
+  &&  (sll res l0 )
+) \/
+(
+forall (l: (@list Z)) (p: Z) (l0_2: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (p = 0)) (PreH2 : (l = (app (l1) (l2)))) (PreH3 : (Permutation l1 l0_2 )) (PreH4 : (increasing l0_2 )) ,
+  (sll p l2 )
+|--
+  “ (Permutation l l0_2 ) ”
+  &&  emp
+).
+
+Definition insertion_sort_return_wit_1_split_goal_1 := 
+forall (l: (@list Z)) (p: Z) (l0_2: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (p = 0)) (PreH2 : (l = (app (l1) (l2)))) (PreH3 : (Permutation l1 l0_2 )) (PreH4 : (increasing l0_2 )) ,
+  (sll p l2 )
+|--
+  “ (Permutation l l0_2 ) ”
+.
+
+Definition insertion_sort_return_wit_1_split_goal_spatial := 
+forall (l: (@list Z)) (p: Z) (l0_2: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (p = 0)) (PreH2 : (l = (app (l1) (l2)))) (PreH3 : (Permutation l1 l0_2 )) (PreH4 : (increasing l0_2 )) ,
+  (sll p l2 )
+|--
+  TT && emp 
+.
+
+Definition insertion_sort_partial_solve_wit_1 := 
+forall (l: (@list Z)) (p: Z) (res: Z) (l0: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (PreH1 : (p <> 0)) (PreH2 : (l = (app (l1) (l2)))) (PreH3 : (Permutation l1 l0 )) (PreH4 : (increasing l0 )) ,
+  (sll res l0 )
+  **  (sll p l2 )
+|--
+  EX (x: Z)  (l0_2: (@list Z))  (y: Z) ,
+  “ (l2 = (cons (x) (l0_2))) ” 
+  &&  “ (p <> 0) ” 
+  &&  “ (l = (app (l1) (l2))) ” 
+  &&  “ (Permutation l1 l0 ) ” 
+  &&  “ (increasing l0 ) ”
+  &&  ((&((p)  # "list" ->ₛ "next")) # Ptr  |-> y)
+  **  (sll y l0_2 )
+  **  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  (sll res l0 )
+.
+
+Definition insertion_sort_partial_solve_wit_2_pure := 
+forall (x_pre: Z) (l: (@list Z)) (p: Z) (res: Z) (l0: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (x: Z) (l0_2: (@list Z)) (y: Z) (PreH1 : (l2 = (cons (x) (l0_2)))) (PreH2 : (p <> 0)) (PreH3 : (l = (app (l1) (l2)))) (PreH4 : (Permutation l1 l0 )) (PreH5 : (increasing l0 )) ,
+  ((&((p)  # "list" ->ₛ "next")) # Ptr  |-> y)
+  **  (sll y l0_2 )
+  **  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "q" ) )) # Ptr  |-> y)
+  **  ((( &( "res" ) )) # Ptr  |-> res)
+  **  (sll res l0 )
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+|--
+  “ (p <> 0) ”
+.
+
+Definition insertion_sort_partial_solve_wit_2_aux := 
+forall (l: (@list Z)) (p: Z) (res: Z) (l0: (@list Z)) (l1: (@list Z)) (l2: (@list Z)) (x: Z) (l0_2: (@list Z)) (y: Z) (PreH1 : (l2 = (cons (x) (l0_2)))) (PreH2 : (p <> 0)) (PreH3 : (l = (app (l1) (l2)))) (PreH4 : (Permutation l1 l0 )) (PreH5 : (increasing l0 )) ,
+  ((&((p)  # "list" ->ₛ "next")) # Ptr  |-> y)
+  **  (sll y l0_2 )
+  **  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  (sll res l0 )
+|--
+  “ (p <> 0) ” 
+  &&  “ (l2 = (cons (x) (l0_2))) ” 
+  &&  “ (p <> 0) ” 
+  &&  “ (l = (app (l1) (l2))) ” 
+  &&  “ (Permutation l1 l0 ) ” 
+  &&  “ (increasing l0 ) ”
+  &&  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  (sll res l0 )
+  **  ((&((p)  # "list" ->ₛ "next")) # Ptr  |->_)
+  **  (sll y l0_2 )
+.
+
+Definition insertion_sort_partial_solve_wit_2 := insertion_sort_partial_solve_wit_2_pure -> insertion_sort_partial_solve_wit_2_aux.
+
+Module Type VC_Correct.
+
+Include sll_Strategy_Correct.
+
+Axiom proof_of_insertion_safety_wit_1 : insertion_safety_wit_1.
+Axiom proof_of_insertion_entail_wit_1 : insertion_entail_wit_1.
+Axiom proof_of_insertion_entail_wit_2 : insertion_entail_wit_2.
+Axiom proof_of_insertion_entail_wit_3_1 : insertion_entail_wit_3_1.
+Axiom proof_of_insertion_entail_wit_3_2 : insertion_entail_wit_3_2.
+Axiom proof_of_insertion_entail_wit_4_1 : insertion_entail_wit_4_1.
+Axiom proof_of_insertion_entail_wit_4_2 : insertion_entail_wit_4_2.
+Axiom proof_of_insertion_return_wit_1 : insertion_return_wit_1.
+Axiom proof_of_insertion_return_wit_2 : insertion_return_wit_2.
+Axiom proof_of_insertion_partial_solve_wit_1 : insertion_partial_solve_wit_1.
+Axiom proof_of_insertion_sort_safety_wit_1 : insertion_sort_safety_wit_1.
+Axiom proof_of_insertion_sort_safety_wit_2 : insertion_sort_safety_wit_2.
+Axiom proof_of_insertion_sort_entail_wit_1 : insertion_sort_entail_wit_1.
+Axiom proof_of_insertion_sort_entail_wit_2 : insertion_sort_entail_wit_2.
+Axiom proof_of_insertion_sort_return_wit_1 : insertion_sort_return_wit_1.
+Axiom proof_of_insertion_sort_partial_solve_wit_1 : insertion_sort_partial_solve_wit_1.
+Axiom proof_of_insertion_sort_partial_solve_wit_2_pure : insertion_sort_partial_solve_wit_2_pure.
+Axiom proof_of_insertion_sort_partial_solve_wit_2 : insertion_sort_partial_solve_wit_2.
+
+End VC_Correct.

benchmarks/Algorithms/sll_insertion_sort/rocq/groundtruth/sll_insertion_sort_goal_check.v

@@ -0,0 +1,7 @@
+From PVbench.Algorithms.sll_insertion_sort.rocq.groundtruth Require Import sll_insertion_sort_goal sll_insertion_sort_proof_auto sll_insertion_sort_proof_manual.
+
+Module VC_Correctness : VC_Correct.
+  Include sll_strategy_proof.
+  Include sll_insertion_sort_proof_auto.
+  Include sll_insertion_sort_proof_manual.
+End VC_Correctness.

benchmarks/Algorithms/sll_insertion_sort/rocq/groundtruth/sll_insertion_sort_proof_auto.v

@@ -0,0 +1,47 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.sll_insertion_sort.rocq.groundtruth Require Import sll_insertion_sort_goal.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import SimpleC.EE.QCP_demos_LLM.sll_lib.
+Require Import PVbench.Algorithms.sll_insertion_sort.rocq.helper_lib.
+Local Open Scope sac.
+
+Lemma proof_of_insertion_safety_wit_1 : insertion_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_insertion_entail_wit_3_2 : insertion_entail_wit_3_2.
+Proof. Admitted. 
+
+Lemma proof_of_insertion_partial_solve_wit_1 : insertion_partial_solve_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_insertion_sort_safety_wit_1 : insertion_sort_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_insertion_sort_safety_wit_2 : insertion_sort_safety_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_insertion_sort_partial_solve_wit_1 : insertion_sort_partial_solve_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_insertion_sort_partial_solve_wit_2_pure : insertion_sort_partial_solve_wit_2_pure.
+Proof. Admitted. 
+
+Lemma proof_of_insertion_sort_partial_solve_wit_2 : insertion_sort_partial_solve_wit_2.
+Proof. Admitted. 
+

benchmarks/Algorithms/sll_insertion_sort/rocq/groundtruth/sll_insertion_sort_proof_manual.v

@@ -0,0 +1,252 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.sll_insertion_sort.rocq.groundtruth Require Import sll_insertion_sort_goal.
+From PVbench.Algorithms.sll_insertion_sort.rocq.groundtruth Require Import sll_insertion_sort_proof_auto.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import SimpleC.EE.QCP_demos_LLM.sll_lib.
+Require Import PVbench.Algorithms.sll_insertion_sort.rocq.helper_lib.
+Require Import PVbench.Algorithms.sll_insertion_sort.rocq.groundtruth.proof_lib.
+Local Open Scope sac.
+
+
+Lemma proof_of_insertion_entail_wit_1 : insertion_entail_wit_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists nil.
+  Exists l.
+  split_pure_spatial.
+  - cancel (&((node_pre) # "list" ->ₛ "data") # Int |-> a).
+    cancel (sll p_pre l).
+    cancel (&((node_pre) # "list" ->ₛ "next") # Ptr |->_).
+    simpl sllbseg.
+    split_pure_spatial.
+    + cancel.
+    + dump_pre_spatial.
+      reflexivity.
+  - split_pures; try (dump_pre_spatial; auto).
+Qed.
+
+Lemma proof_of_insertion_entail_wit_2 : insertion_entail_wit_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists y.
+  Exists (l1_2 ++ x :: nil)%list.
+  Exists l0.
+  split_pure_spatial.
+  - sep_apply (sllbseg_len1 p2 p2_v_2 x); [ | assumption ].
+    sep_apply (sllbseg_sllbseg (&( "res" )) p2 (&((p2_v_2) # "list" ->ₛ "next")) l1_2 (x :: nil)%list).
+    cancel.
+  - split_pures; try (dump_pre_spatial; apply upperbound_app; try assumption; lia).
+    dump_pre_spatial ; auto.
+    dump_pre_spatial.
+    rewrite PreH5.
+    rewrite PreH2.
+    rewrite <- app_assoc.
+    reflexivity.
+Qed.
+
+Lemma proof_of_insertion_entail_wit_3_1 : insertion_entail_wit_3_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  subst p2_v.
+  sep_apply (sll_zero 0 l2); [ | reflexivity ].
+  Intros_p Hl2.
+  Left.
+  Exists l1_3.
+  split_pure_spatial.
+  - cancel ((&((node_pre) # "list" ->ₛ "data")) # Int |-> a).
+    cancel (sllbseg ( &( "res" ) ) p2 l1_3).
+    cancel ((p2) # Ptr |-> 0).
+    cancel ((&((node_pre) # "list" ->ₛ "next")) # Ptr |->_).
+  - split_pures.
+    + dump_pre_spatial.
+      exact PreH2.
+    + dump_pre_spatial.
+      rewrite Hl2 in PreH3.
+      exact PreH3.
+    + dump_pre_spatial.
+      exact PreH4.
+Qed.
+
+Lemma proof_of_insertion_entail_wit_4_1 : insertion_entail_wit_4_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Left.
+  sep_apply (sllbseg_2_sllseg (&( "res" )) p2 node_pre l1_3).
+  Intros resv_2.
+  Exists resv_2.
+  Exists l1_3.
+  split_pure_spatial.
+  - cancel ((( &( "res" ) )) # Ptr |-> resv_2).
+    cancel (sllseg resv_2 node_pre l1_3).
+    cancel ((&((node_pre) # "list" ->ₛ "data")) # Int |-> a).
+    cancel ((&((node_pre) # "list" ->ₛ "next")) # Ptr |-> 0).
+  - split_pures.
+    + dump_pre_spatial.
+      exact PreH1.
+    + dump_pre_spatial.
+      exact PreH2.
+    + dump_pre_spatial.
+      exact PreH3.
+Qed.
+
+Lemma proof_of_insertion_entail_wit_4_2 : insertion_entail_wit_4_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Right.
+  sep_apply (sllbseg_2_sllseg (&( "res" )) p2 node_pre l1_3).
+  Intros resv.
+  Exists unext_2.
+  Exists resv.
+  Exists l1_3.
+  Exists l0_2.
+  Exists x_2.
+  Exists u_2.
+  split_pure_spatial.
+  - cancel ((( &( "res" ) )) # Ptr |-> resv).
+    cancel (sllseg resv node_pre l1_3).
+    cancel ((&((node_pre) # "list" ->ₛ "data")) # Int |-> a).
+    cancel ((&((node_pre) # "list" ->ₛ "next")) # Ptr |-> u_2).
+    cancel ((&((u_2) # "list" ->ₛ "data")) # Int |-> x_2).
+    cancel ((&((u_2) # "list" ->ₛ "next")) # Ptr |-> unext_2).
+    cancel (sll unext_2 l0_2).
+  - split_pures.
+    + dump_pre_spatial.
+      exact PreH1.
+    + dump_pre_spatial.
+      exact PreH2.
+    + dump_pre_spatial.
+      exact PreH3.
+    + dump_pre_spatial.
+      exact PreH4.
+    + dump_pre_spatial.
+      exact PreH5.
+Qed.
+
+Lemma proof_of_insertion_return_wit_1 : insertion_return_wit_1.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  Exists ((l1 ++ a :: nil)%list).
+  split_pure_spatial.
+  - sep_apply (sllseg_len1 node_pre a 0); [ | tauto ].
+    sep_apply (sllseg_sll resv node_pre l1 (a :: nil)%list).
+    cancel (sll resv (l1 ++ a :: nil)%list).
+  - dump_pre_spatial.
+    rewrite PreH2.
+    rewrite app_nil_r.
+    symmetry.
+    apply upperbound_insert_nil.
+    exact PreH3.
+Qed.
+
+Lemma proof_of_insertion_return_wit_2 : insertion_return_wit_2.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  Exists (((l1 ++ a :: nil)%list ++ x :: l0_2)%list).
+  split_pure_spatial.
+  - sep_apply (sllseg_len1 node_pre a u); [ | tauto ].
+    sep_apply (sllseg_sllseg resv node_pre u l1 (a :: nil)%list).
+    sep_apply_r_atomic (sllseg_sll resv u (l1 ++ a :: nil)%list (x :: l0_2)).
+    simpl sll.
+    Exists unext.
+    split_pure_spatial.
+    + cancel (sllseg resv u (l1 ++ a :: nil)%list).
+      cancel ((&((u) # "list" ->ₛ "data")) # Int |-> x).
+      cancel ((&((u) # "list" ->ₛ "next")) # Ptr |-> unext).
+      cancel (sll unext l0_2).
+    + dump_pre_spatial.
+      exact PreH2.
+  - dump_pre_spatial.
+    rewrite PreH4.
+    assert (a <= x) by lia.
+    rewrite (upperbound_insert_cons a l1 l0_2 x PreH5 H).
+    rewrite <- app_assoc.
+    reflexivity.
+Qed.
+
+Lemma proof_of_insertion_sort_entail_wit_1 : insertion_sort_entail_wit_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists nil.
+  Exists nil.
+  Exists l.
+  split_pure_spatial.
+  - simpl sll.
+    split_pure_spatial.
+    + cancel (sll x_pre l).
+    + dump_pre_spatial.
+      reflexivity.
+  - split_pures.
+    + dump_pre_spatial.
+      reflexivity.
+    + dump_pre_spatial.
+      reflexivity.
+Qed.
+
+Lemma proof_of_insertion_sort_entail_wit_2 : insertion_sort_entail_wit_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists l0_4.
+  Exists (l1_2 ++ x :: nil)%list.
+  Exists l0_3.
+  split_pure_spatial.
+  - sep_apply store_ptr_undef_store_ptr.
+    cancel (sll retval l0_4).
+    cancel (sll y l0_3).
+    cancel (((&( "q" ))) # Ptr |->_).
+  - split_pures.
+    + dump_pre_spatial.
+      rewrite PreH4.
+      rewrite PreH2.
+      rewrite <- app_assoc.
+      reflexivity.
+    + dump_pre_spatial.
+      rewrite PreH1.
+      rewrite <- perm_insert.
+      rewrite PreH5.
+      reflexivity.
+    + dump_pre_spatial.
+      rewrite PreH1.
+      apply increasing_insert.
+      exact PreH6.
+Qed.
+
+Lemma proof_of_insertion_sort_return_wit_1 : insertion_sort_return_wit_1.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  rewrite PreH1.
+  sep_apply (sll_zero 0 l2); [ | reflexivity ].
+  Intros_p Hl2.
+  Exists l0_2.
+  split_pure_spatial.
+  - rewrite Hl2 in PreH2.
+    rewrite app_nil_r in PreH2.
+    subst l.
+    cancel (sll res l0_2).
+  - split_pures.
+    + dump_pre_spatial.
+      rewrite Hl2 in PreH2.
+      rewrite app_nil_r in PreH2.
+      subst l.
+      exact PreH3.
+    + dump_pre_spatial.
+      exact PreH4.
+Qed.

benchmarks/Algorithms/sll_insertion_sort/rocq/helper_lib.v

@@ -0,0 +1,23 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Import ListNotations.
+Local Open Scope string.
+Local Open Scope list.
+
+Fixpoint insert (x: Z) (l: list Z): list Z :=
+  match l with
+  | nil => [x]
+  | y :: l' => if x >? y then y :: insert x l' else x :: l
+  end.

benchmarks/Algorithms/sll_insertion_sort/rocq/solution_annotated.c

@@ -0,0 +1,116 @@
+#include "sll_def.h"
+
+/*@ Import Coq Require Import PVbench.Algorithms.sll_insertion_sort.rocq.helper_lib */
+
+/*@ Extern Coq (Permutation: list Z -> list Z -> Prop)
+               (increasing: list Z -> Prop)
+               (insert: Z -> list Z -> list Z)
+               (strict_upperbound: Z -> list Z -> Prop)
+ */
+
+struct list * insertion(struct list * p, struct list * node)
+  /*@ With l a
+      Require node != 0 && node->data == a && 
+              sll(p, l) * 
+              undef_data_at(&(node->next), struct list*) 
+      Ensure exists l0,
+              l0 == insert(a, l) && sll(__return, l0)
+   */
+{
+  struct list * res = p;
+  struct list * * p2 = & res;
+  /*@ Inv Assert
+    exists l1 l2,
+      node == node@pre && p == p@pre &&
+      node != (void *)0 &&
+      l == app(l1, l2) &&
+      node->data == a &&
+      strict_upperbound(a, l1) &&
+      sllbseg(&res, p2, l1) * sll(*p2, l2) *
+      undef_data_at(&(node->next), struct list*)
+  */
+  while (* p2 != (void * )0 && (* p2) -> data < node -> data) {
+    p2 = &((* p2) -> next);
+  }
+  /*@ Assert
+      (exists l1,
+        node == node@pre && p == p@pre &&
+        node != (void *)0 &&
+        l == app(l1, nil) &&
+        node->data == a &&
+        strict_upperbound(a, l1) &&
+        sllbseg(&res, p2, l1) *
+        store(p2, struct list*, (void *)0) *
+        undef_data_at(&(node->next), struct list*))
+      ||
+      (exists l1 x l0 u unext,
+        node == node@pre && p == p@pre &&
+        node != (void *)0 &&
+        u != (void *)0 &&
+        x >= a &&
+        l == app(l1, cons(x, l0)) &&
+        node->data == a &&
+        strict_upperbound(a, l1) &&
+        sllbseg(&res, p2, l1) *
+        store(p2, struct list*, u) *
+        store(&(u->data), x) *
+        store(&(u->next), struct list*, unext) *
+        sll(unext, l0) *
+        undef_data_at(&(node->next), struct list*))
+  */
+  node -> next = * p2;
+  * p2 = node;
+  /*@ Assert
+      (exists resv l1,
+        node == node@pre && p == p@pre &&
+        node != (void *)0 &&
+        l == app(l1, nil) &&
+        strict_upperbound(a, l1) &&
+        store(&p2, struct list**, p2) *
+        store(&res, struct list*, resv) *
+        sllseg(resv, node, l1) *
+        store(&(node->data), a) *
+        store(&(node->next), struct list*, (void *)0))
+      ||
+      (exists resv l1 x l0 u unext,
+        node == node@pre && p == p@pre &&
+        node != (void *)0 &&
+        u != (void *)0 &&
+        x >= a &&
+        l == app(l1, cons(x, l0)) &&
+        strict_upperbound(a, l1) &&
+        store(&p2, struct list**, p2) *
+        store(&res, struct list*, resv) *
+        sllseg(resv, node, l1) *
+          store(&(node->data), a) *
+        store(&(node->next), struct list*, u) *
+        store(&(u->data), x) *
+        store(&(u->next), struct list*, unext) *
+        sll(unext, l0))
+  */
+  return res;
+}
+
+struct list * insertion_sort(struct list * x)
+  /*@ With l
+      Require sll(x, l)
+      Ensure exists l0,
+               Permutation(l, l0) && increasing(l0) &&
+               sll(__return, l0)
+   */
+{
+  struct list * res = (void *)0, * p = x, * q;
+  /*@ Inv Assert
+    exists l0 l1 l2,
+      l == app(l1, l2) && x == x@pre && 
+      Permutation(l1, l0) && increasing(l0) &&
+      has_ptr_permission(&q) *
+      sll(res, l0) * sll(p, l2)
+  */
+  while (p != (void * )0) {
+    q = p -> next;
+    res = insertion(res, p);
+    p = q;
+  }
+  return res;
+}

benchmarks/Algorithms/sll_insertion_sort/rocq/solution_spec.c

@@ -0,0 +1,39 @@
+#include "sll_def.h"
+
+/*@ Extern Coq
+      (Permutation : list Z -> list Z -> Prop)
+      (increasing : list Z -> Prop)
+ */
+
+struct list * insertion(struct list * p, struct list * node)
+{
+  struct list * res = p;
+  struct list * * p2 = & res;
+
+  while (* p2 != (void * )0 && (* p2) -> data < node -> data) {
+    p2 = &((* p2) -> next);
+  }
+
+  node -> next = * p2;
+  * p2 = node;
+
+  return res;
+}
+
+struct list * insertion_sort(struct list * x)
+  /*@ With l
+      Require sll(x, l)
+      Ensure exists l0,
+               Permutation(l, l0) && increasing(l0) &&
+               sll(__return, l0)
+   */
+{
+  struct list * res = (void *)0, * p = x, * q;
+
+  while (p != (void * )0) {
+    q = p -> next;
+    res = insertion(res, p);
+    p = q;
+  }
+  return res;
+}

benchmarks/Algorithms/sll_insertion_sort/solution.c

@@ -0,0 +1,28 @@
+#include "sll_def.h"
+
+struct list * insertion(struct list * p, struct list * node)
+{
+  struct list * res = p;
+  struct list * * p2 = & res;
+
+  while (* p2 != (void * )0 && (* p2) -> data < node -> data) {
+    p2 = &((* p2) -> next);
+  }
+
+  node -> next = * p2;
+  * p2 = node;
+
+  return res;
+}
+
+struct list * insertion_sort(struct list * x)
+{
+  struct list * res = (void *)0, * p = x, * q;
+
+  while (p != (void * )0) {
+    q = p -> next;
+    res = insertion(res, p);
+    p = q;
+  }
+  return res;
+}

benchmarks/Algorithms/sll_merge_sort/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "sll_merge_sort",
+  "source": {
+    "dataset": "classical_algorithm",
+    "problem_id": "sll_merge_sort",
+    "title": "Merge Sort on a Singly Linked List",
+    "tags": [
+      "sort",
+      "merge",
+      "linked list"
+    ]
+  },
+  "stratification": {
+    "band": "unclassified",
+    "output_mode": "CONSTRUCT",
+    "interactive": false,
+    "multi_test": false
+  }
+}

benchmarks/Algorithms/sll_merge_sort/problem.md

@@ -0,0 +1,22 @@
+# Merge Sort on a Singly Linked List
+
+## Description
+
+Sort a null-terminated singly linked list of integers into nondecreasing order using top-down merge sort, relinking the existing nodes.
+
+## Input
+
+A list is given by a pointer to its first node, or `NULL` when empty:
+
+```c
+struct list {
+   int data;
+   struct list *next;
+};
+```
+
+The function receives the head `x` of the list.
+
+## Output
+
+Return the head of a list holding the same values in nondecreasing order.

benchmarks/Algorithms/sll_merge_sort/rocq/groundtruth/proof_lib.v

@@ -0,0 +1,302 @@
+(* Supporting lemmas for the manual proof. *)
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string.
+Local Open Scope list.
+Import naive_C_Rules.
+From SimpleC.EE.QCP_demos_LLM Require Import sll_lib.
+From FP Require Import SetsFixedpoints.
+Require Import MonadLib.StateRelMonad.StateRelMonad.
+Export MonadNotation.
+Require Import PVbench.Algorithms.sll_merge_sort.rocq.helper_lib.
+Local Open Scope monad.
+Local Open Scope sac.
+Import ListNotations.
+Local Open Scope list.
+
+(* From QCP's MonadLib/Examples/mergesort.v: the monadic merge sort is a sorted permutation. *)
+
+Lemma split_rec_rel_unfold: split_rec_rel' == split_rec_rel_f split_rec_rel'.
+Proof.
+  intros.
+  unfold split_rec_rel'.
+  apply Lfix_fixpoint'.
+  unfold split_rec_rel_f.
+  mono_cont_auto.
+Qed. 
+
+
+Lemma split_rec_rel_eval_xnil: forall p q P, 
+  P -@ (split_rec_rel' (nil, p, q)) -⥅ 
+  P ♯ (p, q).
+Proof.
+  intros.
+  erewrite (program_para_equiv (split_rec_rel_unfold)).
+  unfold split_rec_rel_f.
+  apply  highret_eval2.
+Qed.
+
+
+Lemma split_rel_eval_xnotnil: forall z x p q,
+  forall P X, safeExec P (split_rec_rel' (z::x, p, q)) X ->
+              safeExec P (x <- split_rec_rel' (x, q, z::p) ;; reversepair x ) X.
+Proof. 
+  unfold split_rel, reversepair. intros.
+  erewrite (program_para_equiv (split_rec_rel_unfold)) in H.
+  unfold split_rec_rel_f in H.
+  apply H.
+Qed.
+
+Lemma bind_2_reversepair_equiv_Id: 
+  (fun p => z <- reversepair p ;; reversepair z) == ret.
+Proof.
+  intros [x y].
+  unfold reversepair;sets_unfold.
+  intros s [u v] s'.
+  split;intros.
+  - destruct H as ([x' y'] & s'' & ? & ? ).
+    unfold_monad in H. destruct H.
+    unfold_monad in H0. destruct H0.
+    inversion H; inversion H0. subst.
+    unfold_monad. auto.
+  - unfold_monad in H. destruct H.
+    inversion H;subst.
+    do 3 eexists.
+    split;eauto.
+    cbn. sets_unfold. unfold_monad. auto.
+Qed.
+
+Lemma mergesortrec_unfold: mergesortrec == mergesortrec_f mergesortrec.
+Proof.
+  intros.
+  unfold mergesortrec.
+  apply Lfix_fixpoint'.
+  unfold mergesortrec_f.
+  mono_cont_auto.
+Qed.
+
+
+
+Theorem merge_perm:
+  forall l1 l2,
+    Hoare (fun _ => True) 
+          (merge_rel l1 l2) 
+          (fun r _  => Permutation (l1 ++ l2) r).
+Proof.
+  intros.
+  unfold merge_rel.
+  eapply Hoare_conseq_pre.
+  2: 
+  apply (Hoare_repeat_break _
+           (fun '(l1', l2', l3') _ =>
+              Permutation (l1 ++ l2) (l1' ++ l2' ++ l3'))).
+  { intros. simpl. rewrite app_nil_r. reflexivity. } 
+
+  intros [[l1' l2'] l3'].
+  unfold merge_body.
+  destruct l1' as [ | x l1']; [| destruct l2' as [| y l2']].
+  + hoare_auto.
+    rewrite H; simpl.
+    apply Permutation_app_comm.
+  + hoare_auto.
+    rewrite H.
+    rewrite Permutation_app_comm.
+    reflexivity.
+  + hoare_auto. 
+    - rewrite H0.
+      rewrite ! app_assoc.
+      rewrite (Permutation_app_comm _ [x]).
+      reflexivity.
+    - rewrite H0.
+      apply Permutation_app; [reflexivity |].
+      rewrite ! app_assoc.
+      rewrite (Permutation_app_comm _ [y]).
+      reflexivity.
+Qed.
+
+Lemma incr_app_cons: forall l1 x l2,
+  incr (l1 ++ [x]) ->
+  incr (x :: l2) ->
+  incr (l1 ++ x :: l2).
+Proof.
+  intros.
+  simpl in H0.
+  destruct l1 as [| a l1]; simpl in *.
+  { tauto. }
+  revert a H; induction l1; simpl; intros.
+  + tauto.
+  + split; [tauto |].
+    apply IHl1.
+    tauto.
+Qed.
+
+Lemma incr_app_cons_inv1: forall l1 x l2,
+  incr (l1 ++ x :: l2) ->
+  incr (l1 ++ [x]).
+Proof.
+  intros.
+  destruct l1 as [| a l1]; simpl in *.
+  { tauto. }
+  revert a H; induction l1; simpl; intros.
+  + tauto.
+  + split; [tauto |].
+    apply IHl1.
+    tauto.
+Qed.
+
+Lemma incr_app_cons_inv2: forall l1 x l2,
+  incr (l1 ++ x :: l2) ->
+  incr (x :: l2).
+Proof.
+  intros.
+  simpl.
+  induction l1; simpl in *.
+  + tauto.
+  + apply IHl1.
+    destruct l1; simpl in *; tauto.
+Qed.
+
+Theorem merge_incr:
+  forall l1 l2,
+    incr l1 ->
+    incr l2 ->
+    Hoare (fun _ => True) (merge_rel l1 l2) (fun r _ => incr r).
+Proof.
+  intros.
+  unfold merge_rel.
+  eapply Hoare_conseq_pre.
+  2:
+  apply (Hoare_repeat_break _
+           (fun '(l1', l2', l3') _ => 
+              incr (l3' ++ l1') /\
+              incr (l3' ++ l2'))).
+  1: {
+    tauto.
+  }
+  clear l1 l2 H H0.
+  intros [[l1 l2] l3].
+  unfold merge_body.
+  destruct l1 as [ | x l1]; [| destruct l2 as [| y l2]].
+  + hoare_auto. tauto.
+  + hoare_auto. tauto.
+  + hoare_auto.
+    - split.
+      * rewrite <- app_assoc.
+        tauto.
+      * rewrite <- app_assoc.
+        simpl.
+        destruct H0.
+        apply incr_app_cons_inv1 in H0.
+        apply incr_app_cons_inv2 in H1.
+        apply incr_app_cons; simpl in *; tauto.
+    - split.
+      * rewrite <- app_assoc.
+        simpl.
+        destruct H0.
+        apply incr_app_cons_inv1 in H1.
+        apply incr_app_cons_inv2 in H0.
+        apply incr_app_cons; simpl in *; tauto.
+      * rewrite <- app_assoc.
+        tauto.
+Qed.
+
+Theorem functional_correctness_merge:
+  forall l1 l2,
+    incr l1 ->
+    incr l2 ->
+    Hoare (fun _ => True)
+          (merge_rel l1 l2)
+          (fun l3 _ => Permutation (l1 ++ l2) l3 /\ incr l3).
+Proof.
+  intros.
+  apply Hoare_conj.
+  + apply merge_perm.
+  + apply merge_incr; tauto.
+Qed.
+
+
+Theorem functional_correctness_split:
+  forall l,
+    Hoare (fun _ => True)
+          (split_rel l)
+          (fun '(l1, l2) _ => Permutation l (l1 ++ l2) /\ (0 <= length l1 - length l2 <= 1)%nat).
+Proof.
+  intros.
+  unfold split_rel, split_rec_rel'.
+  apply Hoare_conseq_post with (Q2 := fun '(l1, l2) _ => 
+  Permutation ((fst (fst (l, @nil Z, @nil Z))) ++ (snd (fst (l, [], @nil Z))) ++ (snd (l, @nil Z, []))) (l1 ++ l2) /\ 
+  (@length Z (snd (fst (l, [], @nil Z))) <= length l1 /\
+   @length Z (snd (l, @nil Z, [])) <= length l2 /\
+   length l2 - @length Z (snd (l, @nil Z, [])) <= length l1 - @length Z (snd (fst (l, [], @nil Z))) <= S (length l2 - @length Z (snd (l, @nil Z, []))))%nat).
+  { simpl. rewrite app_nil_r. 
+    intros [l1  l2];intros.
+    split; try tauto.
+    lia. }
+  hoare_fix_nolv_auto ((list Z * list Z)%type * list Z)%type.
+  simpl;intros * H [[l0 l1] l2]. simpl.
+  destruct l0.
+  - hoare_auto. split;auto. lia.
+  - eapply Hoare_bind;[apply H |].
+    simpl.
+    intros [? ?].
+    unfold reversepair.
+    hoare_auto.
+    split.
+    + rewrite (Permutation_app_comm l1 l2).
+      rewrite !Permutation_middle.
+      destruct H0 as [H0 _].
+      rewrite H0.
+      apply Permutation_app_comm.
+    + lia. 
+Qed.
+
+
+Theorem functional_correctness_mergesort:
+  forall l,
+    Hoare ATrue (mergesortrec l) (fun l0 _ => Permutation l l0 /\ incr l0).
+Proof.
+  intros.
+  unfold mergesortrec, ATrue.
+  hoare_fix_nolv_auto (list Z).
+  simpl.
+  intros.
+  unfold mergesortrec_f.
+  eapply Hoare_bind;[apply functional_correctness_split | ].
+  intros [l1 l2].
+  destruct l2.
+  - hoare_auto. 
+    rewrite app_nil_r in H0. destruct H0.  split;auto.
+    simpl in H1.
+    destruct l1;[cbn;auto | ].
+    destruct l1;[ | simpl in H1; lia].
+    cbn. auto.
+  - apply Hoare_stateless;intros.
+    eapply Hoare_bind;[apply H| ].
+    intros lp;simpl.
+    apply Hoare_stateless;intros.
+    eapply Hoare_bind;[apply H| ].
+    intros lq;simpl.
+    apply Hoare_stateless;intros.
+    eapply Hoare_conseq_post.
+    2: { apply functional_correctness_merge;try tauto. }
+    destruct H0.
+    destruct H1. destruct H2.
+    intros lr ? [? ?].
+    rewrite H0.
+    rewrite H1, H2.
+    tauto.
+Qed.
+
+

benchmarks/Algorithms/sll_merge_sort/rocq/groundtruth/sll_merge_sort_goal.v

@@ -0,0 +1,900 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import SimpleC.EE.QCP_demos_LLM.sll_lib.
+From MonadLib Require Export MonadLib.
+From MonadLib.StateRelMonad Require Export StateRelMonad.
+Export MonadNotation.
+Local Open Scope monad.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap relations.
+From FP Require Import PartialOrder_Setoid BourbakiWitt.
+Require Import PVbench.Algorithms.sll_merge_sort.rocq.spec_lib.
+Require Import PVbench.Algorithms.sll_merge_sort.rocq.helper_lib.
+Local Open Scope sac.
+From SimpleC.EE.QCP_demos_LLM Require Import sll_strategy_goal.
+From SimpleC.EE.QCP_demos_LLM Require Import sll_strategy_proof.
+From SimpleC.EE.QCP_demos_LLM Require Import safeexec_strategy_goal.
+From SimpleC.EE.QCP_demos_LLM Require Import safeexec_strategy_proof.
+
+(*----- Function merge -----*)
+
+Definition merge_safety_wit_1 := 
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1: (@list Z)) (l2: (@list Z)) (l3: (@list Z)) (PreH1 : (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X )) ,
+  ((( &( "x" ) )) # Ptr  |-> x)
+  **  (sll x l1 )
+  **  ((( &( "y" ) )) # Ptr  |-> y)
+  **  (sll y l2 )
+  **  ((( &( "t" ) )) # Ptr  |-> t)
+  **  ((t) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+|--
+  “ (1 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 1) ”
+.
+
+Definition merge_safety_wit_2 := 
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1: (@list Z)) (l2: (@list Z)) (l3: (@list Z)) (PreH1 : (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X )) ,
+  ((( &( "x" ) )) # Ptr  |-> x)
+  **  (sll x l1 )
+  **  ((( &( "y" ) )) # Ptr  |-> y)
+  **  (sll y l2 )
+  **  ((( &( "t" ) )) # Ptr  |-> t)
+  **  ((t) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition merge_safety_wit_3 := 
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1: (@list Z)) (l2: (@list Z)) (l3: (@list Z)) (PreH1 : (x <> 0)) (PreH2 : (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X )) ,
+  ((( &( "x" ) )) # Ptr  |-> x)
+  **  (sll x l1 )
+  **  ((( &( "y" ) )) # Ptr  |-> y)
+  **  (sll y l2 )
+  **  ((( &( "t" ) )) # Ptr  |-> t)
+  **  ((t) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition merge_entail_wit_1 := 
+(
+forall (y_pre: Z) (x_pre: Z) (X: ((@list Z) -> (unit -> Prop))) (s2: (@list Z)) (s1: (@list Z)) (PreH1 : (safeExec ATrue (merge_rel (s1) (s2)) X )) ,
+  ((( &( "ret" ) )) # Ptr  |->_)
+  **  (sll x_pre s1 )
+  **  (sll y_pre s2 )
+|--
+  EX (l1: (@list Z))  (l2: (@list Z))  (l3: (@list Z)) ,
+  “ (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X ) ”
+  &&  (sll x_pre l1 )
+  **  (sll y_pre l2 )
+  **  ((( &( "ret" ) )) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) ( &( "ret" ) ) l3 )
+) \/
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (s2: (@list Z)) (s1: (@list Z)) (PreH1 : (safeExec ATrue (merge_rel (s1) (s2)) X )) ,
+  TT && emp 
+|--
+  “ (safeExec ATrue (merge_from_mid_rel (s1) (s2) ((@nil Z))) X ) ”
+  &&  emp
+).
+
+Definition merge_entail_wit_1_split_goal_1 := 
+forall (X: ((@list Z) -> (unit -> Prop))) (s2: (@list Z)) (s1: (@list Z)) (PreH1 : (safeExec ATrue (merge_rel (s1) (s2)) X )) ,
+  (safeExec ATrue (merge_from_mid_rel (s1) (s2) ((@nil Z))) X )
+.
+
+Definition merge_entail_wit_2 := 
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1_2: (@list Z)) (l2_2: (@list Z)) (l3_2: (@list Z)) (PreH1 : (y <> 0)) (PreH2 : (x <> 0)) (PreH3 : (safeExec ATrue (merge_from_mid_rel (l1_2) (l2_2) (l3_2)) X )) ,
+  (sll x l1_2 )
+  **  (sll y l2_2 )
+  **  ((t) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) t l3_2 )
+|--
+  EX (ynext: Z)  (xnext: Z)  (ydata: Z)  (l2_new: (@list Z))  (xdata: Z)  (l1_new: (@list Z))  (l1: (@list Z))  (l2: (@list Z))  (l3: (@list Z)) ,
+  “ (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X ) ” 
+  &&  “ (x <> 0) ” 
+  &&  “ (y <> 0) ” 
+  &&  “ (l1 = (cons (xdata) (l1_new))) ” 
+  &&  “ (l2 = (cons (ydata) (l2_new))) ”
+  &&  ((&((x)  # "list" ->ₛ "data")) # Int  |-> xdata)
+  **  ((&((y)  # "list" ->ₛ "data")) # Int  |-> ydata)
+  **  ((&((x)  # "list" ->ₛ "next")) # Ptr  |-> xnext)
+  **  ((&((y)  # "list" ->ₛ "next")) # Ptr  |-> ynext)
+  **  (sll xnext l1_new )
+  **  (sll ynext l2_new )
+  **  ((t) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+.
+
+Definition merge_entail_wit_3_1 := 
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (l1_2: (@list Z)) (l2_2: (@list Z)) (l3_2: (@list Z)) (l1_new: (@list Z)) (l2_new: (@list Z)) (xdata: Z) (ydata: Z) (xnext: Z) (ynext: Z) (x: Z) (y: Z) (t: Z) (PreH1 : (xdata < ydata)) (PreH2 : (safeExec ATrue (merge_from_mid_rel (l1_2) (l2_2) (l3_2)) X )) (PreH3 : (x <> 0)) (PreH4 : (y <> 0)) (PreH5 : (l1_2 = (cons (xdata) (l1_new)))) (PreH6 : (l2_2 = (cons (ydata) (l2_new)))) ,
+  ((&((x)  # "list" ->ₛ "data")) # Int  |-> xdata)
+  **  ((&((y)  # "list" ->ₛ "data")) # Int  |-> ydata)
+  **  ((&((x)  # "list" ->ₛ "next")) # Ptr  |-> xnext)
+  **  ((&((y)  # "list" ->ₛ "next")) # Ptr  |-> ynext)
+  **  (sll xnext l1_new )
+  **  (sll ynext l2_new )
+  **  ((t) # Ptr  |-> x)
+  **  (sllbseg ( &( "ret" ) ) t l3_2 )
+|--
+  EX (l1: (@list Z))  (l2: (@list Z))  (l3: (@list Z)) ,
+  “ (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X ) ”
+  &&  (sll xnext l1 )
+  **  (sll y l2 )
+  **  ((&((x)  # "list" ->ₛ "next")) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) &((x)  # "list" ->ₛ "next") l3 )
+) \/
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (l1_2: (@list Z)) (l2_2: (@list Z)) (l3_2: (@list Z)) (l1_new: (@list Z)) (l2_new: (@list Z)) (xdata: Z) (ydata: Z) (x: Z) (y: Z) (t: Z) (PreH1 : (xdata <= INT_MAX)) (PreH2 : (xdata >= INT_MIN)) (PreH3 : (xdata < ydata)) (PreH4 : (safeExec ATrue (merge_from_mid_rel (l1_2) (l2_2) (l3_2)) X )) (PreH5 : (x <> 0)) (PreH6 : (y <> 0)) (PreH7 : (l1_2 = (cons (xdata) (l1_new)))) (PreH8 : (l2_2 = (cons (ydata) (l2_new)))) ,
+  ((&((x)  # "list" ->ₛ "data")) # Int  |-> xdata)
+  **  ((t) # Ptr  |-> x)
+  **  (sllbseg ( &( "ret" ) ) t l3_2 )
+|--
+  EX (l3: (@list Z)) ,
+  “ (y <> 0) ” 
+  &&  “ (safeExec ATrue (merge_from_mid_rel (l1_new) ((cons (ydata) (l2_new))) (l3)) X ) ”
+  &&  (sllbseg ( &( "ret" ) ) &((x)  # "list" ->ₛ "next") l3 )
+).
+
+Definition merge_entail_wit_3_2 := 
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (l1_2: (@list Z)) (l2_2: (@list Z)) (l3_2: (@list Z)) (l1_new: (@list Z)) (l2_new: (@list Z)) (xdata: Z) (ydata: Z) (xnext: Z) (ynext: Z) (x: Z) (y: Z) (t: Z) (PreH1 : (xdata >= ydata)) (PreH2 : (safeExec ATrue (merge_from_mid_rel (l1_2) (l2_2) (l3_2)) X )) (PreH3 : (x <> 0)) (PreH4 : (y <> 0)) (PreH5 : (l1_2 = (cons (xdata) (l1_new)))) (PreH6 : (l2_2 = (cons (ydata) (l2_new)))) ,
+  ((&((x)  # "list" ->ₛ "data")) # Int  |-> xdata)
+  **  ((&((y)  # "list" ->ₛ "data")) # Int  |-> ydata)
+  **  ((&((x)  # "list" ->ₛ "next")) # Ptr  |-> xnext)
+  **  ((&((y)  # "list" ->ₛ "next")) # Ptr  |-> ynext)
+  **  (sll xnext l1_new )
+  **  (sll ynext l2_new )
+  **  ((t) # Ptr  |-> y)
+  **  (sllbseg ( &( "ret" ) ) t l3_2 )
+|--
+  EX (l1: (@list Z))  (l2: (@list Z))  (l3: (@list Z)) ,
+  “ (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X ) ”
+  &&  (sll x l1 )
+  **  (sll ynext l2 )
+  **  ((&((y)  # "list" ->ₛ "next")) # Ptr  |->_)
+  **  (sllbseg ( &( "ret" ) ) &((y)  # "list" ->ₛ "next") l3 )
+) \/
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (l1_2: (@list Z)) (l2_2: (@list Z)) (l3_2: (@list Z)) (l1_new: (@list Z)) (l2_new: (@list Z)) (xdata: Z) (ydata: Z) (x: Z) (y: Z) (t: Z) (PreH1 : (ydata <= INT_MAX)) (PreH2 : (ydata >= INT_MIN)) (PreH3 : (xdata >= ydata)) (PreH4 : (safeExec ATrue (merge_from_mid_rel (l1_2) (l2_2) (l3_2)) X )) (PreH5 : (x <> 0)) (PreH6 : (y <> 0)) (PreH7 : (l1_2 = (cons (xdata) (l1_new)))) (PreH8 : (l2_2 = (cons (ydata) (l2_new)))) ,
+  ((&((y)  # "list" ->ₛ "data")) # Int  |-> ydata)
+  **  ((t) # Ptr  |-> y)
+  **  (sllbseg ( &( "ret" ) ) t l3_2 )
+|--
+  EX (l3: (@list Z)) ,
+  “ (x <> 0) ” 
+  &&  “ (safeExec ATrue (merge_from_mid_rel ((cons (xdata) (l1_new))) (l2_new) (l3)) X ) ”
+  &&  (sllbseg ( &( "ret" ) ) &((y)  # "list" ->ₛ "next") l3 )
+).
+
+Definition merge_entail_wit_4_1 := 
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1: (@list Z)) (l2: (@list Z)) (l3: (@list Z)) (PreH1 : (x = 0)) (PreH2 : (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X )) ,
+  (sll x l1 )
+  **  (sll y l2 )
+  **  ((t) # Ptr  |-> y)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+|--
+  EX (ret: Z)  (s3: (@list Z)) ,
+  “ (safeExec ATrue (return (s3)) X ) ”
+  &&  ((( &( "ret" ) )) # Ptr  |-> ret)
+  **  (sll ret s3 )
+) \/
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1: (@list Z)) (l2: (@list Z)) (l3: (@list Z)) (PreH1 : (x = 0)) (PreH2 : (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X )) ,
+  (sll x l1 )
+  **  (sll y l2 )
+  **  ((t) # Ptr  |-> y)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+|--
+  EX (ret: Z)  (s3: (@list Z)) ,
+  “ (safeExec ATrue (return (s3)) X ) ”
+  &&  ((( &( "ret" ) )) # Ptr  |-> ret)
+  **  (sll ret s3 )
+).
+
+Definition merge_entail_wit_4_2 := 
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1: (@list Z)) (l2: (@list Z)) (l3: (@list Z)) (PreH1 : (y = 0)) (PreH2 : (x <> 0)) (PreH3 : (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X )) ,
+  (sll x l1 )
+  **  (sll y l2 )
+  **  ((t) # Ptr  |-> x)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+|--
+  EX (ret: Z)  (s3: (@list Z)) ,
+  “ (safeExec ATrue (return (s3)) X ) ”
+  &&  ((( &( "ret" ) )) # Ptr  |-> ret)
+  **  (sll ret s3 )
+) \/
+(
+forall (X: ((@list Z) -> (unit -> Prop))) (t: Z) (y: Z) (x: Z) (l1: (@list Z)) (l2: (@list Z)) (l3: (@list Z)) (PreH1 : (y = 0)) (PreH2 : (x <> 0)) (PreH3 : (safeExec ATrue (merge_from_mid_rel (l1) (l2) (l3)) X )) ,
+  (sll x l1 )
+  **  (sll y l2 )
+  **  ((t) # Ptr  |-> x)
+  **  (sllbseg ( &( "ret" ) ) t l3 )
+|--
+  EX (ret: Z)  (s3: (@list Z)) ,
+  “ (safeExec ATrue (return (s3)) X ) ”
+  &&  ((( &( "ret" ) )) # Ptr  |-> ret)
+  **  (sll ret s3 )
+).
+
+Definition merge_return_wit_1 := 
+forall (X: ((@list Z) -> (unit -> Prop))) (s3_2: (@list Z)) (ret: Z) (PreH1 : (safeExec ATrue (return (s3_2)) X )) ,
+  (sll ret s3_2 )
+|--
+  EX (s3: (@list Z)) ,
+  “ (safeExec ATrue (return (s3)) X ) ”
+  &&  (sll ret s3 )
+.
+
+(*----- Function split_rec -----*)
+
+Definition split_rec_safety_wit_1 := 
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_low_level_spec: Z) (pv_low_level_spec: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (PreH1 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p_pre)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  ((p_pre) # Ptr  |-> pv_low_level_spec)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre l_low_level_spec )
+  **  (sll pv_low_level_spec l1_low_level_spec )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition split_rec_entail_wit_1 := 
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_low_level_spec: Z) (pv_low_level_spec: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (PreH1 : (x_pre <> 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) ,
+  ((p_pre) # Ptr  |-> pv_low_level_spec)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre l_low_level_spec )
+  **  (sll pv_low_level_spec l1_low_level_spec )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+|--
+  EX (x_next: Z)  (x_data: Z)  (l_new: (@list Z)) ,
+  “ (x_pre <> 0) ” 
+  &&  “ (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec ) ” 
+  &&  “ (l_low_level_spec = (cons (x_data) (l_new))) ”
+  &&  ((&((x_pre)  # "list" ->ₛ "data")) # Int  |-> x_data)
+  **  ((&((x_pre)  # "list" ->ₛ "next")) # Ptr  |-> x_next)
+  **  ((p_pre) # Ptr  |-> pv_low_level_spec)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_next l_new )
+  **  (sll pv_low_level_spec l1_low_level_spec )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+.
+
+Definition split_rec_entail_wit_2 := 
+(
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_low_level_spec: Z) (pv_low_level_spec: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (l_new_2: (@list Z)) (x_data_2: Z) (x_next: Z) (PreH1 : (x_pre <> 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) (PreH3 : (l_low_level_spec = (cons (x_data_2) (l_new_2)))) ,
+  ((&((x_pre)  # "list" ->ₛ "data")) # Int  |-> x_data_2)
+  **  ((&((x_pre)  # "list" ->ₛ "next")) # Ptr  |-> pv_low_level_spec)
+  **  ((p_pre) # Ptr  |-> x_pre)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_next l_new_2 )
+  **  (sll pv_low_level_spec l1_low_level_spec )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+|--
+  EX (l_new: (@list Z))  (x_data: Z) ,
+  “ (x_pre <> 0) ” 
+  &&  “ (safeExec ATrue (bind ((split_rec_rel (l_new) (l2_low_level_spec) ((cons (x_data) (l1_low_level_spec))))) (reversepair)) X_low_level_spec ) ” 
+  &&  “ (l_low_level_spec = (cons (x_data) (l_new))) ”
+  &&  ((p_pre) # Ptr  |-> x_pre)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre (cons (x_data) (l1_low_level_spec)) )
+  **  (sll x_next l_new )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+) \/
+(
+forall (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (l_new_2: (@list Z)) (x_data_2: Z) (PreH1 : (x_pre <> 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) (PreH3 : (l_low_level_spec = (cons (x_data_2) (l_new_2)))) ,
+  TT && emp 
+|--
+  “ (safeExec ATrue (bind ((split_rec_rel (l_new_2) (l2_low_level_spec) ((cons (x_data_2) (l1_low_level_spec))))) (reversepair)) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition split_rec_entail_wit_2_split_goal_1 := 
+forall (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (l_new_2: (@list Z)) (x_data_2: Z) (PreH1 : (x_pre <> 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) (PreH3 : (l_low_level_spec = (cons (x_data_2) (l_new_2)))) ,
+  (safeExec ATrue (bind ((split_rec_rel (l_new_2) (l2_low_level_spec) ((cons (x_data_2) (l1_low_level_spec))))) (reversepair)) X_low_level_spec )
+.
+
+Definition split_rec_return_wit_1 := 
+(
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_low_level_spec: Z) (pv_low_level_spec: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (PreH1 : (x_pre = 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) ,
+  ((p_pre) # Ptr  |-> pv_low_level_spec)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre l_low_level_spec )
+  **  (sll pv_low_level_spec l1_low_level_spec )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+|--
+  EX (qv': Z)  (pv': Z)  (s1: (@list Z))  (s2: (@list Z)) ,
+  “ (safeExec ATrue (return ((maketuple (s1) (s2)))) X_low_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv')
+  **  ((q_pre) # Ptr  |-> qv')
+  **  (sll pv' s1 )
+  **  (sll qv' s2 )
+) \/
+(
+forall (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (PreH1 : (x_pre = 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) ,
+  (sll x_pre l_low_level_spec )
+|--
+  “ (safeExec ATrue (return ((maketuple (l1_low_level_spec) (l2_low_level_spec)))) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition split_rec_return_wit_1_split_goal_1 := 
+forall (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (PreH1 : (x_pre = 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) ,
+  (sll x_pre l_low_level_spec )
+|--
+  “ (safeExec ATrue (return ((maketuple (l1_low_level_spec) (l2_low_level_spec)))) X_low_level_spec ) ”
+.
+
+Definition split_rec_return_wit_1_split_goal_spatial := 
+forall (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (PreH1 : (x_pre = 0)) (PreH2 : (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec )) ,
+  (sll x_pre l_low_level_spec )
+|--
+  TT && emp 
+.
+
+Definition split_rec_return_wit_2 := 
+(
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (l_new: (@list Z)) (x_data: Z) (qv'_2: Z) (pv'_2: Z) (s1_2: (@list Z)) (s2_2: (@list Z)) (PreH1 : (safeExec ATrue (applyf (reversepair) ((maketuple (s1_2) (s2_2)))) X_low_level_spec )) (PreH2 : (x_pre <> 0)) (PreH3 : (l_low_level_spec = (cons (x_data) (l_new)))) ,
+  ((q_pre) # Ptr  |-> pv'_2)
+  **  ((p_pre) # Ptr  |-> qv'_2)
+  **  (sll pv'_2 s1_2 )
+  **  (sll qv'_2 s2_2 )
+|--
+  EX (qv': Z)  (pv': Z)  (s1: (@list Z))  (s2: (@list Z)) ,
+  “ (safeExec ATrue (return ((maketuple (s1) (s2)))) X_low_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv')
+  **  ((q_pre) # Ptr  |-> qv')
+  **  (sll pv' s1 )
+  **  (sll qv' s2 )
+) \/
+(
+forall (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (l_new: (@list Z)) (x_data: Z) (s1_2: (@list Z)) (s2_2: (@list Z)) (PreH1 : (safeExec ATrue (applyf (reversepair) ((maketuple (s1_2) (s2_2)))) X_low_level_spec )) (PreH2 : (x_pre <> 0)) (PreH3 : (l_low_level_spec = (cons (x_data) (l_new)))) ,
+  TT && emp 
+|--
+  “ (safeExec ATrue (return ((maketuple (s2_2) (s1_2)))) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition split_rec_return_wit_2_split_goal_1 := 
+forall (x_pre: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (l_new: (@list Z)) (x_data: Z) (s1_2: (@list Z)) (s2_2: (@list Z)) (PreH1 : (safeExec ATrue (applyf (reversepair) ((maketuple (s1_2) (s2_2)))) X_low_level_spec )) (PreH2 : (x_pre <> 0)) (PreH3 : (l_low_level_spec = (cons (x_data) (l_new)))) ,
+  (safeExec ATrue (return ((maketuple (s2_2) (s1_2)))) X_low_level_spec )
+.
+
+Definition split_rec_partial_solve_wit_1_pure := 
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_low_level_spec: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (l_new: (@list Z)) (x_data: Z) (t: Z) (PreH1 : (x_pre <> 0)) (PreH2 : (safeExec ATrue (bind ((split_rec_rel (l_new) (l2_low_level_spec) ((cons (x_data) (l1_low_level_spec))))) (reversepair)) X_low_level_spec )) (PreH3 : (l_low_level_spec = (cons (x_data) (l_new)))) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p_pre)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  ((p_pre) # Ptr  |-> x_pre)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre (cons (x_data) (l1_low_level_spec)) )
+  **  ((( &( "t" ) )) # Ptr  |-> t)
+  **  (sll t l_new )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+|--
+  “ (safeExec ATrue (bind ((split_rec_rel (l_new) (l2_low_level_spec) ((cons (x_data) (l1_low_level_spec))))) (reversepair)) X_low_level_spec ) ”
+.
+
+Definition split_rec_partial_solve_wit_1_aux := 
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_low_level_spec: Z) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l2_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l_low_level_spec: (@list Z)) (l_new: (@list Z)) (x_data: Z) (t: Z) (PreH1 : (x_pre <> 0)) (PreH2 : (safeExec ATrue (bind ((split_rec_rel (l_new) (l2_low_level_spec) ((cons (x_data) (l1_low_level_spec))))) (reversepair)) X_low_level_spec )) (PreH3 : (l_low_level_spec = (cons (x_data) (l_new)))) ,
+  ((p_pre) # Ptr  |-> x_pre)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre (cons (x_data) (l1_low_level_spec)) )
+  **  (sll t l_new )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+|--
+  “ (safeExec ATrue (bind ((split_rec_rel (l_new) (l2_low_level_spec) ((cons (x_data) (l1_low_level_spec))))) (reversepair)) X_low_level_spec ) ” 
+  &&  “ (x_pre <> 0) ” 
+  &&  “ (safeExec ATrue (bind ((split_rec_rel (l_new) (l2_low_level_spec) ((cons (x_data) (l1_low_level_spec))))) (reversepair)) X_low_level_spec ) ” 
+  &&  “ (l_low_level_spec = (cons (x_data) (l_new))) ”
+  &&  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  ((p_pre) # Ptr  |-> x_pre)
+  **  (sll t l_new )
+  **  (sll qv_low_level_spec l2_low_level_spec )
+  **  (sll x_pre (cons (x_data) (l1_low_level_spec)) )
+.
+
+Definition split_rec_partial_solve_wit_1 := split_rec_partial_solve_wit_1_pure -> split_rec_partial_solve_wit_1_aux.
+
+(*----- Function merge_sort -----*)
+
+Definition merge_sort_safety_wit_1 := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (PreH1 : (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec )) ,
+  ((( &( "q" ) )) # Ptr  |->_)
+  **  ((( &( "p" ) )) # Ptr  |->_)
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition merge_sort_safety_wit_2 := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (PreH1 : (p = 0)) (PreH2 : (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  ((( &( "q" ) )) # Ptr  |->_)
+  **  (sll p (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition merge_sort_safety_wit_3 := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (pv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH2 : (q = 0)) (PreH3 : (p = 0)) (PreH4 : (p = 0)) (PreH5 : (q = 0)) ,
+  ((( &( "p" ) )) # Ptr  |-> pv')
+  **  ((( &( "q" ) )) # Ptr  |-> qv')
+  **  (sll pv' s1 )
+  **  (sll qv' s2 )
+  **  ((( &( "x" ) )) # Ptr  |-> x_pre)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition merge_sort_entail_wit_1 := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (PreH1 : (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec )) ,
+  (sll x_pre l_low_level_spec )
+|--
+  “ (0 = 0) ” 
+  &&  “ (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec ) ”
+  &&  (sll 0 (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+.
+
+Definition merge_sort_entail_wit_2 := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (PreH1 : (p = 0)) (PreH2 : (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec )) ,
+  (sll p (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (p = 0) ” 
+  &&  “ (0 = 0) ” 
+  &&  “ (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec ) ”
+  &&  (sll p (@nil Z) )
+  **  (sll 0 (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+.
+
+Definition merge_sort_entail_wit_3 := 
+(
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (q: Z) (PreH1 : (p = 0)) (PreH2 : (q = 0)) (PreH3 : (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec )) ,
+  (sll p (@nil Z) )
+  **  (sll q (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (p = 0) ” 
+  &&  “ (q = 0) ” 
+  &&  “ (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec ) ”
+  &&  (sll p (@nil Z) )
+  **  (sll q (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+) \/
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (q: Z) (PreH1 : (q = 0)) (PreH2 : (p = 0)) (PreH3 : (p = 0)) (PreH4 : (q = 0)) (PreH5 : (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec )) ,
+  TT && emp 
+|--
+  “ (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition merge_sort_entail_wit_3_split_goal_1 := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (q: Z) (PreH1 : (q = 0)) (PreH2 : (p = 0)) (PreH3 : (p = 0)) (PreH4 : (q = 0)) (PreH5 : (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec )) ,
+  (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec )
+.
+
+Definition merge_sort_entail_wit_4 := 
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (pv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (qv' <> 0)) (PreH2 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH3 : (q = 0)) (PreH4 : (p = 0)) (PreH5 : (p = 0)) (PreH6 : (q = 0)) ,
+  (sll pv' s1 )
+  **  (sll qv' s2 )
+|--
+  EX (l1: (@list Z))  (l2: (@list Z)) ,
+  “ (qv' <> 0) ” 
+  &&  “ (safeExec ATrue (bind ((mergesortrec (l1))) ((mergesortrec_loc1 (l2)))) X_low_level_spec ) ”
+  &&  (sll pv' l1 )
+  **  (sll qv' l2 )
+) \/
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (qv' <> 0)) (PreH2 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH3 : (q = 0)) (PreH4 : (p = 0)) (PreH5 : (p = 0)) (PreH6 : (q = 0)) ,
+  TT && emp 
+|--
+  “ (safeExec ATrue (bind ((mergesortrec (s1))) ((mergesortrec_loc1 (s2)))) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition merge_sort_entail_wit_4_split_goal_1 := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (qv' <> 0)) (PreH2 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH3 : (q = 0)) (PreH4 : (p = 0)) (PreH5 : (p = 0)) (PreH6 : (q = 0)) ,
+  (safeExec ATrue (bind ((mergesortrec (s1))) ((mergesortrec_loc1 (s2)))) X_low_level_spec )
+.
+
+Definition merge_sort_entail_wit_5 := 
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l2_2: (@list Z)) (q: Z) (l0: (@list Z)) (retval: Z) (PreH1 : (safeExec ATrue (applyf ((mergesortrec_loc1 (l2_2))) (l0)) X_low_level_spec )) (PreH2 : (q <> 0)) ,
+  (sll retval l0 )
+  **  (sll q l2_2 )
+|--
+  EX (l2: (@list Z))  (l1: (@list Z)) ,
+  “ (q <> 0) ” 
+  &&  “ (safeExec ATrue (bind ((mergesortrec (l2))) ((mergesortrec_loc2 (l1)))) X_low_level_spec ) ”
+  &&  (sll retval l1 )
+  **  (sll q l2 )
+) \/
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l2_2: (@list Z)) (q: Z) (l0: (@list Z)) (PreH1 : (safeExec ATrue (applyf ((mergesortrec_loc1 (l2_2))) (l0)) X_low_level_spec )) (PreH2 : (q <> 0)) ,
+  TT && emp 
+|--
+  “ (safeExec ATrue (bind ((mergesortrec (l2_2))) ((mergesortrec_loc2 (l0)))) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition merge_sort_entail_wit_5_split_goal_1 := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l2_2: (@list Z)) (q: Z) (l0: (@list Z)) (PreH1 : (safeExec ATrue (applyf ((mergesortrec_loc1 (l2_2))) (l0)) X_low_level_spec )) (PreH2 : (q <> 0)) ,
+  (safeExec ATrue (bind ((mergesortrec (l2_2))) ((mergesortrec_loc2 (l0)))) X_low_level_spec )
+.
+
+Definition merge_sort_entail_wit_6 := 
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1_2: (@list Z)) (q: Z) (p: Z) (l0: (@list Z)) (retval: Z) (PreH1 : (safeExec ATrue (applyf ((mergesortrec_loc2 (l1_2))) (l0)) X_low_level_spec )) (PreH2 : (q <> 0)) ,
+  (sll retval l0 )
+  **  (sll p l1_2 )
+|--
+  EX (l1: (@list Z))  (l2: (@list Z)) ,
+  “ (safeExec ATrue (merge_rel (l1) (l2)) X_low_level_spec ) ”
+  &&  (sll p l1 )
+  **  (sll retval l2 )
+) \/
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1_2: (@list Z)) (q: Z) (l0: (@list Z)) (PreH1 : (safeExec ATrue (applyf ((mergesortrec_loc2 (l1_2))) (l0)) X_low_level_spec )) (PreH2 : (q <> 0)) ,
+  TT && emp 
+|--
+  “ (safeExec ATrue (merge_rel (l1_2) (l0)) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition merge_sort_entail_wit_6_split_goal_1 := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1_2: (@list Z)) (q: Z) (l0: (@list Z)) (PreH1 : (safeExec ATrue (applyf ((mergesortrec_loc2 (l1_2))) (l0)) X_low_level_spec )) (PreH2 : (q <> 0)) ,
+  (safeExec ATrue (merge_rel (l1_2) (l0)) X_low_level_spec )
+.
+
+Definition merge_sort_return_wit_1 := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (s3: (@list Z)) (retval: Z) (PreH1 : (safeExec ATrue (return (s3)) X_low_level_spec )) ,
+  (sll retval s3 )
+|--
+  EX (l0: (@list Z)) ,
+  “ (safeExec ATrue (return (l0)) X_low_level_spec ) ”
+  &&  (sll retval l0 )
+.
+
+Definition merge_sort_return_wit_2 := 
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (pv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (qv' = 0)) (PreH2 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH3 : (q = 0)) (PreH4 : (p = 0)) (PreH5 : (p = 0)) (PreH6 : (q = 0)) ,
+  (sll pv' s1 )
+  **  (sll qv' s2 )
+|--
+  EX (l0: (@list Z)) ,
+  “ (safeExec ATrue (return (l0)) X_low_level_spec ) ”
+  &&  (sll pv' l0 )
+) \/
+(
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (qv' = 0)) (PreH2 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH3 : (q = 0)) (PreH4 : (p = 0)) (PreH5 : (p = 0)) (PreH6 : (q = 0)) ,
+  (sll qv' s2 )
+|--
+  “ (safeExec ATrue (return (s1)) X_low_level_spec ) ”
+  &&  emp
+).
+
+Definition merge_sort_return_wit_2_split_goal_1 := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (qv' = 0)) (PreH2 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH3 : (q = 0)) (PreH4 : (p = 0)) (PreH5 : (p = 0)) (PreH6 : (q = 0)) ,
+  (sll qv' s2 )
+|--
+  “ (safeExec ATrue (return (s1)) X_low_level_spec ) ”
+.
+
+Definition merge_sort_return_wit_2_split_goal_spatial := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (p: Z) (q: Z) (qv': Z) (s1: (@list Z)) (s2: (@list Z)) (PreH1 : (qv' = 0)) (PreH2 : (safeExec ATrue (applyf (mergesortrec_loc0) ((maketuple (s1) (s2)))) X_low_level_spec )) (PreH3 : (q = 0)) (PreH4 : (p = 0)) (PreH5 : (p = 0)) (PreH6 : (q = 0)) ,
+  (sll qv' s2 )
+|--
+  TT && emp 
+.
+
+Definition merge_sort_partial_solve_wit_1_pure := 
+(
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (q: Z) (PreH1 : (p = 0)) (PreH2 : (q = 0)) (PreH3 : (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  ((( &( "q" ) )) # Ptr  |-> q)
+  **  (sll p (@nil Z) )
+  **  (sll q (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (safeExec ATrue (bind ((split_rec_rel (l_low_level_spec) ((@nil Z)) ((@nil Z)))) (mergesortrec_loc0)) X_low_level_spec ) ”
+) \/
+(
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (q: Z) (PreH1 : (q = 0)) (PreH2 : (p = 0)) (PreH3 : (p = 0)) (PreH4 : (q = 0)) (PreH5 : (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  ((( &( "q" ) )) # Ptr  |-> q)
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (safeExec ATrue (bind ((split_rec_rel (l_low_level_spec) ((@nil Z)) ((@nil Z)))) (mergesortrec_loc0)) X_low_level_spec ) ”
+).
+
+Definition merge_sort_partial_solve_wit_1_pure_split_goal_1 := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (q: Z) (PreH1 : (q = 0)) (PreH2 : (p = 0)) (PreH3 : (p = 0)) (PreH4 : (q = 0)) (PreH5 : (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  ((( &( "q" ) )) # Ptr  |-> q)
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (safeExec ATrue (bind ((split_rec_rel (l_low_level_spec) ((@nil Z)) ((@nil Z)))) (mergesortrec_loc0)) X_low_level_spec ) ”
+.
+
+Definition merge_sort_partial_solve_wit_1_aux := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l_low_level_spec: (@list Z)) (p: Z) (q: Z) (PreH1 : (p = 0)) (PreH2 : (q = 0)) (PreH3 : (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec )) ,
+  (sll p (@nil Z) )
+  **  (sll q (@nil Z) )
+  **  (sll x_pre l_low_level_spec )
+|--
+  “ (safeExec ATrue (bind ((split_rec_rel (l_low_level_spec) ((@nil Z)) ((@nil Z)))) (mergesortrec_loc0)) X_low_level_spec ) ” 
+  &&  “ (q = 0) ” 
+  &&  “ (p = 0) ” 
+  &&  “ (p = 0) ” 
+  &&  “ (q = 0) ” 
+  &&  “ (safeExec ATrue (bind ((split_rel (l_low_level_spec))) (mergesortrec_loc0)) X_low_level_spec ) ”
+  &&  (sll x_pre l_low_level_spec )
+  **  (sll p (@nil Z) )
+  **  (sll q (@nil Z) )
+.
+
+Definition merge_sort_partial_solve_wit_1 := merge_sort_partial_solve_wit_1_pure -> merge_sort_partial_solve_wit_1_aux.
+
+Definition merge_sort_partial_solve_wit_2_pure := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1: (@list Z)) (l2: (@list Z)) (q: Z) (p: Z) (PreH1 : (q <> 0)) (PreH2 : (safeExec ATrue (bind ((mergesortrec (l1))) ((mergesortrec_loc1 (l2)))) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "q" ) )) # Ptr  |-> q)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  (sll p l1 )
+  **  (sll q l2 )
+|--
+  “ (safeExec ATrue (bind ((mergesortrec (l1))) ((mergesortrec_loc1 (l2)))) X_low_level_spec ) ”
+.
+
+Definition merge_sort_partial_solve_wit_2_aux := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1: (@list Z)) (l2: (@list Z)) (q: Z) (p: Z) (PreH1 : (q <> 0)) (PreH2 : (safeExec ATrue (bind ((mergesortrec (l1))) ((mergesortrec_loc1 (l2)))) X_low_level_spec )) ,
+  (sll p l1 )
+  **  (sll q l2 )
+|--
+  “ (safeExec ATrue (bind ((mergesortrec (l1))) ((mergesortrec_loc1 (l2)))) X_low_level_spec ) ” 
+  &&  “ (q <> 0) ” 
+  &&  “ (safeExec ATrue (bind ((mergesortrec (l1))) ((mergesortrec_loc1 (l2)))) X_low_level_spec ) ”
+  &&  (sll p l1 )
+  **  (sll q l2 )
+.
+
+Definition merge_sort_partial_solve_wit_2 := merge_sort_partial_solve_wit_2_pure -> merge_sort_partial_solve_wit_2_aux.
+
+Definition merge_sort_partial_solve_wit_3_pure := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1: (@list Z)) (l2: (@list Z)) (q: Z) (p: Z) (PreH1 : (q <> 0)) (PreH2 : (safeExec ATrue (bind ((mergesortrec (l2))) ((mergesortrec_loc2 (l1)))) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "q" ) )) # Ptr  |-> q)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  (sll p l1 )
+  **  (sll q l2 )
+|--
+  “ (safeExec ATrue (bind ((mergesortrec (l2))) ((mergesortrec_loc2 (l1)))) X_low_level_spec ) ”
+.
+
+Definition merge_sort_partial_solve_wit_3_aux := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1: (@list Z)) (l2: (@list Z)) (q: Z) (p: Z) (PreH1 : (q <> 0)) (PreH2 : (safeExec ATrue (bind ((mergesortrec (l2))) ((mergesortrec_loc2 (l1)))) X_low_level_spec )) ,
+  (sll p l1 )
+  **  (sll q l2 )
+|--
+  “ (safeExec ATrue (bind ((mergesortrec (l2))) ((mergesortrec_loc2 (l1)))) X_low_level_spec ) ” 
+  &&  “ (q <> 0) ” 
+  &&  “ (safeExec ATrue (bind ((mergesortrec (l2))) ((mergesortrec_loc2 (l1)))) X_low_level_spec ) ”
+  &&  (sll q l2 )
+  **  (sll p l1 )
+.
+
+Definition merge_sort_partial_solve_wit_3 := merge_sort_partial_solve_wit_3_pure -> merge_sort_partial_solve_wit_3_aux.
+
+Definition merge_sort_partial_solve_wit_4_pure := 
+forall (x_pre: Z) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1: (@list Z)) (l2: (@list Z)) (p: Z) (q: Z) (PreH1 : (safeExec ATrue (merge_rel (l1) (l2)) X_low_level_spec )) ,
+  ((( &( "x" ) )) # Ptr  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  (sll p l1 )
+  **  ((( &( "q" ) )) # Ptr  |-> q)
+  **  (sll q l2 )
+|--
+  “ (safeExec ATrue (merge_rel (l1) (l2)) X_low_level_spec ) ”
+.
+
+Definition merge_sort_partial_solve_wit_4_aux := 
+forall (X_low_level_spec: ((@list Z) -> (unit -> Prop))) (l1: (@list Z)) (l2: (@list Z)) (p: Z) (q: Z) (PreH1 : (safeExec ATrue (merge_rel (l1) (l2)) X_low_level_spec )) ,
+  (sll p l1 )
+  **  (sll q l2 )
+|--
+  “ (safeExec ATrue (merge_rel (l1) (l2)) X_low_level_spec ) ” 
+  &&  “ (safeExec ATrue (merge_rel (l1) (l2)) X_low_level_spec ) ”
+  &&  (sll p l1 )
+  **  (sll q l2 )
+.
+
+Definition merge_sort_partial_solve_wit_4 := merge_sort_partial_solve_wit_4_pure -> merge_sort_partial_solve_wit_4_aux.
+
+Definition merge_sort_derive_low_level_spec_aux_by_low_level_spec := 
+forall (B: Type) ,
+forall (x_pre: Z) (X_low_level_spec_aux: (B -> (unit -> Prop))) (c_low_level_spec_aux: ((@list Z) -> (@ StateRelMonad.M  unit B))) (l_low_level_spec_aux: (@list Z)) ,
+  “ (safeExec ATrue (bind ((mergesortrec (l_low_level_spec_aux))) (c_low_level_spec_aux)) X_low_level_spec_aux ) ”
+  &&  (sll x_pre l_low_level_spec_aux )
+|--
+EX (l_low_level_spec: (@list Z)) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) ,
+  (“ (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec ) ”
+  &&  (sll x_pre l_low_level_spec ))
+  **
+  ((EX l0_2 retval_2,
+  “ (safeExec ATrue (return (l0_2)) X_low_level_spec ) ”
+  &&  (sll retval_2 l0_2 ))
+  -*
+  (EX l0 retval,
+  “ (safeExec ATrue (applyf (c_low_level_spec_aux) (l0)) X_low_level_spec_aux ) ”
+  &&  (sll retval l0 )))
+.
+
+Definition merge_sort_derive_high_level_spec_by_low_level_spec := 
+forall (x_pre: Z) (l_high_level_spec: (@list Z)) ,
+  (sll x_pre l_high_level_spec )
+|--
+EX (l_low_level_spec: (@list Z)) (X_low_level_spec: ((@list Z) -> (unit -> Prop))) ,
+  (“ (safeExec ATrue (mergesortrec (l_low_level_spec)) X_low_level_spec ) ”
+  &&  (sll x_pre l_low_level_spec ))
+  **
+  ((EX l0_2 retval_2,
+  “ (safeExec ATrue (return (l0_2)) X_low_level_spec ) ”
+  &&  (sll retval_2 l0_2 ))
+  -*
+  (EX l0 retval,
+  “ (Permutation l_high_level_spec l0 ) ” 
+  &&  “ (incr l0 ) ”
+  &&  (sll retval l0 )))
+.
+
+Definition split_rec_derive_low_level_spec_aux_by_low_level_spec := 
+forall (B: Type) ,
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_low_level_spec_aux: Z) (pv_low_level_spec_aux: Z) (X_low_level_spec_aux: (B -> (unit -> Prop))) (c_low_level_spec_aux: (((@list Z) * (@list Z)) -> (@ StateRelMonad.M  unit B))) (l2_low_level_spec_aux: (@list Z)) (l1_low_level_spec_aux: (@list Z)) (l_low_level_spec_aux: (@list Z)) ,
+  “ (safeExec ATrue (bind ((split_rec_rel (l_low_level_spec_aux) (l1_low_level_spec_aux) (l2_low_level_spec_aux))) (c_low_level_spec_aux)) X_low_level_spec_aux ) ”
+  &&  ((p_pre) # Ptr  |-> pv_low_level_spec_aux)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec_aux)
+  **  (sll x_pre l_low_level_spec_aux )
+  **  (sll pv_low_level_spec_aux l1_low_level_spec_aux )
+  **  (sll qv_low_level_spec_aux l2_low_level_spec_aux )
+|--
+EX (l_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l2_low_level_spec: (@list Z)) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (pv_low_level_spec: Z) (qv_low_level_spec: Z) ,
+  (“ (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv_low_level_spec)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre l_low_level_spec )
+  **  (sll pv_low_level_spec l1_low_level_spec )
+  **  (sll qv_low_level_spec l2_low_level_spec ))
+  **
+  ((EX qv'_2 pv'_2 s1_2 s2_2,
+  “ (safeExec ATrue (return ((maketuple (s1_2) (s2_2)))) X_low_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv'_2)
+  **  ((q_pre) # Ptr  |-> qv'_2)
+  **  (sll pv'_2 s1_2 )
+  **  (sll qv'_2 s2_2 ))
+  -*
+  (EX qv' pv' s1 s2,
+  “ (safeExec ATrue (applyf (c_low_level_spec_aux) ((maketuple (s1) (s2)))) X_low_level_spec_aux ) ”
+  &&  ((p_pre) # Ptr  |-> pv')
+  **  ((q_pre) # Ptr  |-> qv')
+  **  (sll pv' s1 )
+  **  (sll qv' s2 )))
+.
+
+Definition split_rec_derive_high_level_spec_by_low_level_spec := 
+forall (q_pre: Z) (p_pre: Z) (x_pre: Z) (qv_high_level_spec: Z) (pv_high_level_spec: Z) (X_high_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (l_high_level_spec: (@list Z)) ,
+  “ (safeExec ATrue (split_rel (l_high_level_spec)) X_high_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv_high_level_spec)
+  **  ((q_pre) # Ptr  |-> qv_high_level_spec)
+  **  (sll x_pre l_high_level_spec )
+  **  (sll pv_high_level_spec nil )
+  **  (sll qv_high_level_spec nil )
+|--
+EX (l_low_level_spec: (@list Z)) (l1_low_level_spec: (@list Z)) (l2_low_level_spec: (@list Z)) (X_low_level_spec: (((@list Z) * (@list Z)) -> (unit -> Prop))) (pv_low_level_spec: Z) (qv_low_level_spec: Z) ,
+  (“ (safeExec ATrue (split_rec_rel (l_low_level_spec) (l1_low_level_spec) (l2_low_level_spec)) X_low_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv_low_level_spec)
+  **  ((q_pre) # Ptr  |-> qv_low_level_spec)
+  **  (sll x_pre l_low_level_spec )
+  **  (sll pv_low_level_spec l1_low_level_spec )
+  **  (sll qv_low_level_spec l2_low_level_spec ))
+  **
+  ((EX qv'_2 pv'_2 s1_2 s2_2,
+  “ (safeExec ATrue (return ((maketuple (s1_2) (s2_2)))) X_low_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv'_2)
+  **  ((q_pre) # Ptr  |-> qv'_2)
+  **  (sll pv'_2 s1_2 )
+  **  (sll qv'_2 s2_2 ))
+  -*
+  (EX qv' pv' s1 s2,
+  “ (safeExec ATrue (return ((maketuple (s1) (s2)))) X_high_level_spec ) ”
+  &&  ((p_pre) # Ptr  |-> pv')
+  **  ((q_pre) # Ptr  |-> qv')
+  **  (sll pv' s1 )
+  **  (sll qv' s2 )))
+.
+
+Module Type VC_Correct.
+
+Include sll_Strategy_Correct.
+Include safeexec_Strategy_Correct.
+
+Axiom proof_of_merge_safety_wit_1 : merge_safety_wit_1.
+Axiom proof_of_merge_safety_wit_2 : merge_safety_wit_2.
+Axiom proof_of_merge_safety_wit_3 : merge_safety_wit_3.
+Axiom proof_of_merge_entail_wit_1 : merge_entail_wit_1.
+Axiom proof_of_merge_entail_wit_2 : merge_entail_wit_2.
+Axiom proof_of_merge_entail_wit_3_1 : merge_entail_wit_3_1.
+Axiom proof_of_merge_entail_wit_3_2 : merge_entail_wit_3_2.
+Axiom proof_of_merge_entail_wit_4_1 : merge_entail_wit_4_1.
+Axiom proof_of_merge_entail_wit_4_2 : merge_entail_wit_4_2.
+Axiom proof_of_merge_return_wit_1 : merge_return_wit_1.
+Axiom proof_of_split_rec_safety_wit_1 : split_rec_safety_wit_1.
+Axiom proof_of_split_rec_entail_wit_1 : split_rec_entail_wit_1.
+Axiom proof_of_split_rec_entail_wit_2 : split_rec_entail_wit_2.
+Axiom proof_of_split_rec_return_wit_1 : split_rec_return_wit_1.
+Axiom proof_of_split_rec_return_wit_2 : split_rec_return_wit_2.
+Axiom proof_of_split_rec_partial_solve_wit_1_pure : split_rec_partial_solve_wit_1_pure.
+Axiom proof_of_split_rec_partial_solve_wit_1 : split_rec_partial_solve_wit_1.
+Axiom proof_of_merge_sort_safety_wit_1 : merge_sort_safety_wit_1.
+Axiom proof_of_merge_sort_safety_wit_2 : merge_sort_safety_wit_2.
+Axiom proof_of_merge_sort_safety_wit_3 : merge_sort_safety_wit_3.
+Axiom proof_of_merge_sort_entail_wit_1 : merge_sort_entail_wit_1.
+Axiom proof_of_merge_sort_entail_wit_2 : merge_sort_entail_wit_2.
+Axiom proof_of_merge_sort_entail_wit_3 : merge_sort_entail_wit_3.
+Axiom proof_of_merge_sort_entail_wit_4 : merge_sort_entail_wit_4.
+Axiom proof_of_merge_sort_entail_wit_5 : merge_sort_entail_wit_5.
+Axiom proof_of_merge_sort_entail_wit_6 : merge_sort_entail_wit_6.
+Axiom proof_of_merge_sort_return_wit_1 : merge_sort_return_wit_1.
+Axiom proof_of_merge_sort_return_wit_2 : merge_sort_return_wit_2.
+Axiom proof_of_merge_sort_partial_solve_wit_1_pure : merge_sort_partial_solve_wit_1_pure.
+Axiom proof_of_merge_sort_partial_solve_wit_1 : merge_sort_partial_solve_wit_1.
+Axiom proof_of_merge_sort_partial_solve_wit_2_pure : merge_sort_partial_solve_wit_2_pure.
+Axiom proof_of_merge_sort_partial_solve_wit_2 : merge_sort_partial_solve_wit_2.
+Axiom proof_of_merge_sort_partial_solve_wit_3_pure : merge_sort_partial_solve_wit_3_pure.
+Axiom proof_of_merge_sort_partial_solve_wit_3 : merge_sort_partial_solve_wit_3.
+Axiom proof_of_merge_sort_partial_solve_wit_4_pure : merge_sort_partial_solve_wit_4_pure.
+Axiom proof_of_merge_sort_partial_solve_wit_4 : merge_sort_partial_solve_wit_4.
+Axiom proof_of_merge_sort_derive_low_level_spec_aux_by_low_level_spec : merge_sort_derive_low_level_spec_aux_by_low_level_spec.
+Axiom proof_of_merge_sort_derive_high_level_spec_by_low_level_spec : merge_sort_derive_high_level_spec_by_low_level_spec.
+Axiom proof_of_split_rec_derive_low_level_spec_aux_by_low_level_spec : split_rec_derive_low_level_spec_aux_by_low_level_spec.
+Axiom proof_of_split_rec_derive_high_level_spec_by_low_level_spec : split_rec_derive_high_level_spec_by_low_level_spec.
+
+End VC_Correct.

benchmarks/Algorithms/sll_merge_sort/rocq/groundtruth/sll_merge_sort_goal_check.v

@@ -0,0 +1,8 @@
+From PVbench.Algorithms.sll_merge_sort.rocq.groundtruth Require Import sll_merge_sort_goal sll_merge_sort_proof_auto sll_merge_sort_proof_manual.
+
+Module VC_Correctness : VC_Correct.
+  Include sll_strategy_proof.
+  Include safeexec_strategy_proof.
+  Include sll_merge_sort_proof_auto.
+  Include sll_merge_sort_proof_manual.
+End VC_Correctness.

benchmarks/Algorithms/sll_merge_sort/rocq/groundtruth/sll_merge_sort_proof_auto.v

@@ -0,0 +1,96 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.sll_merge_sort.rocq.groundtruth Require Import sll_merge_sort_goal.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import SimpleC.EE.QCP_demos_LLM.sll_lib.
+From MonadLib Require Export MonadLib.
+From MonadLib.StateRelMonad Require Export StateRelMonad.
+Export MonadNotation.
+Local Open Scope monad.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap relations.
+From FP Require Import PartialOrder_Setoid BourbakiWitt.
+Require Import PVbench.Algorithms.sll_merge_sort.rocq.spec_lib.
+Require Import PVbench.Algorithms.sll_merge_sort.rocq.helper_lib.
+Local Open Scope sac.
+
+Lemma proof_of_merge_safety_wit_1 : merge_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_merge_safety_wit_2 : merge_safety_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_merge_safety_wit_3 : merge_safety_wit_3.
+Proof. Admitted. 
+
+Lemma proof_of_merge_entail_wit_2 : merge_entail_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_merge_return_wit_1 : merge_return_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_split_rec_safety_wit_1 : split_rec_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_split_rec_entail_wit_1 : split_rec_entail_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_split_rec_partial_solve_wit_1_pure : split_rec_partial_solve_wit_1_pure.
+Proof. Admitted. 
+
+Lemma proof_of_split_rec_partial_solve_wit_1 : split_rec_partial_solve_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_safety_wit_1 : merge_sort_safety_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_safety_wit_2 : merge_sort_safety_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_safety_wit_3 : merge_sort_safety_wit_3.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_entail_wit_1 : merge_sort_entail_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_entail_wit_2 : merge_sort_entail_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_return_wit_1 : merge_sort_return_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_partial_solve_wit_1 : merge_sort_partial_solve_wit_1.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_partial_solve_wit_2_pure : merge_sort_partial_solve_wit_2_pure.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_partial_solve_wit_2 : merge_sort_partial_solve_wit_2.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_partial_solve_wit_3_pure : merge_sort_partial_solve_wit_3_pure.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_partial_solve_wit_3 : merge_sort_partial_solve_wit_3.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_partial_solve_wit_4_pure : merge_sort_partial_solve_wit_4_pure.
+Proof. Admitted. 
+
+Lemma proof_of_merge_sort_partial_solve_wit_4 : merge_sort_partial_solve_wit_4.
+Proof. Admitted. 
+

benchmarks/Algorithms/sll_merge_sort/rocq/groundtruth/sll_merge_sort_proof_manual.v

@@ -0,0 +1,421 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+From PVbench.Algorithms.sll_merge_sort.rocq.groundtruth Require Import sll_merge_sort_goal.
+From PVbench.Algorithms.sll_merge_sort.rocq.groundtruth Require Import sll_merge_sort_proof_auto.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import SimpleC.EE.QCP_demos_LLM.sll_lib.
+From MonadLib Require Export MonadLib.
+From MonadLib.StateRelMonad Require Export StateRelMonad.
+Export MonadNotation.
+Local Open Scope monad.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap relations.
+From FP Require Import PartialOrder_Setoid BourbakiWitt.
+Require Import PVbench.Algorithms.sll_merge_sort.rocq.helper_lib.
+From SimpleC.EE.QCP_demos_LLM Require Import sll_lib.
+Require Import PVbench.Algorithms.sll_merge_sort.rocq.groundtruth.proof_lib.
+Local Open Scope sac.
+
+
+Lemma proof_of_merge_entail_wit_1 : merge_entail_wit_1.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  Exists s1. Exists s2. Exists (@nil Z).
+  repeat (split_pure_spatial || split_pures).
+  + cancel (sll x_pre s1).
+    cancel (sll y_pre s2).
+    cancel (((&( "ret" ))) # Ptr |->_).
+    simpl.
+    split_pure_spatial.
+    - cancel.
+    - dump_pre_spatial. reflexivity.
+  + dump_pre_spatial.
+    unfold merge_rel, merge_from_mid_rel.
+    exact PreH1.
+Qed.
+
+Lemma proof_of_merge_entail_wit_3_1 : merge_entail_wit_3_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists l1_new. Exists (ydata :: l2_new). Exists (l3_2 ++ (xdata :: nil))%list.
+  simpl sll. Exists ynext.
+  repeat (split_pure_spatial || split_pures).
+  + cancel (&((y) # "list" ->ₛ"data") # Int |-> ydata).
+    cancel (&((y) # "list" ->ₛ"next") # Ptr |-> ynext).
+    cancel (sll ynext l2_new).
+    cancel (sll xnext l1_new).
+    sep_apply_l_atomic (sllbseg_len1 t x xdata).
+    * dump_pre_spatial. exact PreH3.
+    * sep_apply_l_atomic (store_ptr_undef_store_ptr (&((x) # "list" ->ₛ"next")) xnext).
+      cancel (&((x) # "list" ->ₛ"next") # Ptr |->_).
+      sep_apply_l_atomic (sllbseg_sllbseg (&( "ret")) t (&((x) # "list" ->ₛ"next")) l3_2 (xdata :: nil)).
+      cancel (sllbseg (&( "ret")) (&((x) # "list" ->ₛ"next")) (l3_2 ++ (xdata :: nil))%list).
+  + dump_pre_spatial.
+    rewrite PreH5 in PreH2.
+    rewrite PreH6 in PreH2.
+    unfold merge_from_mid_rel in PreH2 at 1.
+    prog_nf in PreH2.
+    unfold_loop in PreH2.
+    prog_nf in PreH2.
+    unfold merge_body in PreH2 at 1.
+    prog_nf in PreH2.
+    safe_choice_l PreH2; try lia.
+    exact PreH2.
+  + dump_pre_spatial. exact PreH4.
+Qed.
+
+Lemma proof_of_merge_entail_wit_3_2 : merge_entail_wit_3_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists (xdata :: l1_new). Exists l2_new. Exists (l3_2 ++ (ydata :: nil))%list.
+  simpl sll. Exists xnext.
+  repeat (split_pure_spatial || split_pures).
+  + cancel (&((x) # "list" ->ₛ"data") # Int |-> xdata).
+    cancel (&((x) # "list" ->ₛ"next") # Ptr |-> xnext).
+    cancel (sll xnext l1_new).
+    cancel (sll ynext l2_new).
+    sep_apply_l_atomic (sllbseg_len1 t y ydata).
+    * dump_pre_spatial. exact PreH4.
+    * sep_apply_l_atomic (store_ptr_undef_store_ptr (&((y) # "list" ->ₛ"next")) ynext).
+      cancel (&((y) # "list" ->ₛ"next") # Ptr |->_).
+      sep_apply_l_atomic (sllbseg_sllbseg (&( "ret")) t (&((y) # "list" ->ₛ"next")) l3_2 (ydata :: nil)).
+      cancel (sllbseg (&( "ret")) (&((y) # "list" ->ₛ"next")) (l3_2 ++ (ydata :: nil))%list).
+  + dump_pre_spatial.
+    rewrite PreH5 in PreH2.
+    rewrite PreH6 in PreH2.
+    unfold merge_from_mid_rel in PreH2 at 1.
+    prog_nf in PreH2.
+    unfold_loop in PreH2.
+    prog_nf in PreH2.
+    unfold merge_body in PreH2 at 1.
+    prog_nf in PreH2.
+    safe_choice_r PreH2; try lia.
+    exact PreH2.
+  + dump_pre_spatial. exact PreH3.
+Qed.
+
+Lemma proof_of_merge_entail_wit_4_1 : merge_entail_wit_4_1.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  subst x.
+  sep_apply_l_atomic (sll_zero 0 l1).
+  * dump_pre_spatial. reflexivity.
+  * Intros_p Hl1nil.
+    subst l1.
+    sep_apply_l_atomic (sllbseg_2_sllseg (&( "ret")) t y l3).
+    Intros ret.
+    Exists ret. Exists (l3 ++ l2).
+    repeat (split_pure_spatial || split_pures).
+    + cancel (&( "ret") # Ptr |-> ret).
+      sep_apply_l_atomic (sllseg_sll ret y l3 l2).
+      cancel (sll ret (l3 ++ l2)).
+    + dump_pre_spatial.
+      unfold merge_from_mid_rel in PreH2 at 1.
+      prog_nf in PreH2.
+      unfold_loop in PreH2.
+      prog_nf in PreH2.
+      unfold merge_body in PreH2 at 1.
+      prog_nf in PreH2.
+      exact PreH2.
+Qed.
+
+Lemma proof_of_merge_entail_wit_4_2 : merge_entail_wit_4_2.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  subst y.
+  sep_apply_l_atomic (sll_zero 0 l2).
+  * dump_pre_spatial. reflexivity.
+  * Intros_p Hl2nil.
+    subst l2.
+    sep_apply_l_atomic (sllbseg_2_sllseg (&( "ret")) t x l3).
+    Intros ret.
+    Exists ret. Exists (l3 ++ l1).
+    repeat (split_pure_spatial || split_pures).
+    + cancel (&( "ret") # Ptr |-> ret).
+      sep_apply_l_atomic (sllseg_sll ret x l3 l1).
+      cancel (sll ret (l3 ++ l1)).
+    + dump_pre_spatial.
+      unfold merge_from_mid_rel in PreH3 at 1.
+      prog_nf in PreH3.
+      unfold_loop in PreH3.
+      prog_nf in PreH3.
+      unfold merge_body in PreH3 at 1.
+      destruct l1 as [|h tl]; prog_nf in PreH3; exact PreH3.
+Qed.
+
+Lemma proof_of_split_rec_return_wit_2 : split_rec_return_wit_2.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  Exists pv'_2. Exists qv'_2. Exists s2_2. Exists s1_2.
+  repeat (split_pure_spatial || split_pures).
+  + cancel ((q_pre) # Ptr |-> pv'_2).
+    cancel (sll pv'_2 s1_2).
+    cancel ((p_pre) # Ptr |-> qv'_2).
+    cancel (sll qv'_2 s2_2).
+  + dump_pre_spatial.
+    unfold reversepair, applyf.
+    exact PreH1.
+Qed.
+
+Lemma proof_of_split_rec_return_wit_1 : split_rec_return_wit_1.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  subst x_pre.
+  sep_apply_l_atomic (sll_zero 0 l_low_level_spec).
+  * dump_pre_spatial. reflexivity.
+  * Intros_p Hlnil.
+    subst l_low_level_spec.
+    Exists qv_low_level_spec. Exists pv_low_level_spec. Exists l1_low_level_spec. Exists l2_low_level_spec.
+    repeat (split_pure_spatial || split_pures).
+    + cancel ((p_pre) # Ptr |-> pv_low_level_spec).
+      cancel (sll pv_low_level_spec l1_low_level_spec).
+      cancel ((q_pre) # Ptr |-> qv_low_level_spec).
+      cancel (sll qv_low_level_spec l2_low_level_spec).
+    + dump_pre_spatial.
+      unfold split_rec_rel in PreH2.
+      rewrite (split_rec_rel_unfold (nil, l1_low_level_spec, l2_low_level_spec)) in PreH2.
+      simpl in PreH2.
+      exact PreH2.
+Qed.
+
+Lemma proof_of_split_rec_entail_wit_2 : split_rec_entail_wit_2.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  Exists l_new_2. Exists x_data_2.
+  repeat (split_pure_spatial || split_pures).
+  + cancel ((q_pre) # Ptr |-> qv_low_level_spec).
+    cancel (sll qv_low_level_spec l2_low_level_spec).
+    cancel (sll x_next l_new_2).
+    simpl sll.
+    Exists pv_low_level_spec.
+    split_pure_spatial.
+    - cancel (&((x_pre) # "list" ->ₛ"data") # Int |-> x_data_2).
+      cancel (&((x_pre) # "list" ->ₛ"next") # Ptr |-> pv_low_level_spec).
+      cancel (sll pv_low_level_spec l1_low_level_spec).
+      cancel.
+    - dump_pre_spatial. exact PreH1.
+  + dump_pre_spatial. exact PreH1.
+  + dump_pre_spatial.
+    rewrite PreH3 in PreH2.
+    unfold split_rec_rel in PreH2.
+    rewrite (split_rec_rel_unfold (x_data_2 :: l_new_2, l1_low_level_spec, l2_low_level_spec)) in PreH2.
+    simpl in PreH2.
+    exact PreH2.
+  + dump_pre_spatial. exact PreH3.
+Qed.
+
+Lemma proof_of_merge_sort_partial_solve_wit_1_pure : merge_sort_partial_solve_wit_1_pure.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+Qed.
+
+Lemma proof_of_merge_sort_entail_wit_3 : merge_sort_entail_wit_3.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  subst p. subst q.
+  simpl sll.
+  repeat (split_pure_spatial || split_pures).
+  + Intros_p Hp0. Intros_p Hq0. cancel.
+  + dump_pre_spatial. reflexivity.
+  + dump_pre_spatial. reflexivity.
+  + dump_pre_spatial.
+    unfold mergesortrec in PreH3 at 1.
+    erewrite (program_para_equiv (mergesortrec_unfold)) in PreH3.
+    unfold mergesortrec_f, mergesortrec_loc0 in PreH3.
+    exact PreH3.
+  + dump_pre_spatial. reflexivity.
+  + dump_pre_spatial. reflexivity.
+Qed.
+
+Lemma proof_of_merge_sort_entail_wit_4 : merge_sort_entail_wit_4.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  sep_apply_l_atomic (sll_not_zero qv' s2).
+  - dump_pre_spatial. exact PreH1.
+  - Intros q_next. Intros h. Intros t.
+    Exists s1. Exists (h :: t).
+    repeat (split_pure_spatial || split_pures).
+    + cancel (sll pv' s1).
+      simpl.
+      Exists q_next.
+      repeat (split_pure_spatial || split_pures).
+      * cancel (&(qv' # "list" ->ₛ"data") # Int |-> h).
+        cancel (&(qv' # "list" ->ₛ"next") # Ptr |-> q_next).
+        cancel (sll q_next t).
+      * dump_pre_spatial. exact PreH1.
+    + dump_pre_spatial. exact PreH1.
+    + dump_pre_spatial.
+      unfold applyf, maketuple, mergesortrec_loc0 in PreH2.
+      rewrite H in PreH2.
+      simpl in PreH2. exact PreH2.
+Qed.
+
+Lemma proof_of_merge_sort_entail_wit_5 : merge_sort_entail_wit_5.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  Exists l2_2. Exists l0.
+  repeat (split_pure_spatial || split_pures).
+  + cancel (sll retval l0).
+    cancel (sll q l2_2).
+  + dump_pre_spatial. exact PreH2.
+  + dump_pre_spatial.
+    unfold applyf, mergesortrec_loc1 in PreH1.
+    unfold mergesortrec_loc2.
+    exact PreH1.
+Qed.
+
+Lemma proof_of_merge_sort_entail_wit_6 : merge_sort_entail_wit_6.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  Exists l1_2. Exists l0.
+  repeat (split_pure_spatial || split_pures).
+  + cancel (sll retval l0).
+    cancel (sll p l1_2).
+  + dump_pre_spatial.
+    unfold applyf in PreH1 at 1.
+    unfold mergesortrec_loc2 in PreH1 at 1.
+    prog_nf in PreH1.
+    exact PreH1.
+Qed.
+
+Lemma proof_of_merge_sort_return_wit_2 : merge_sort_return_wit_2.
+Proof.
+  left.
+  LLM_pre_process ltac:(int_auto).
+  sep_apply_l_atomic (sll_zero qv' s2).
+  * dump_pre_spatial. rewrite PreH1. reflexivity.
+  * Intros_p Hs2nil.
+    subst s2.
+    Exists s1.
+    repeat (split_pure_spatial || split_pures).
+    + cancel (sll pv' s1).
+    + dump_pre_spatial.
+      unfold applyf, maketuple, mergesortrec_loc0.
+      simpl.
+      exact PreH2.
+Qed.
+
+Lemma proof_of_merge_sort_derive_low_level_spec_aux_by_low_level_spec : merge_sort_derive_low_level_spec_aux_by_low_level_spec.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  apply safeExec_bind in H as (X_low_level_spec & Hsafe_first & Hsafe_cont).
+  Exists l_low_level_spec_aux.
+  Exists X_low_level_spec.
+  split_pure_spatial.
+  + cancel (sll x_pre l_low_level_spec_aux).
+    apply derivable1_wand_sepcon_adjoint.
+    Intros l0_2. Intros retval_2.
+    Exists l0_2. Exists retval_2.
+    repeat (split_pure_spatial || split_pures).
+    - cancel (sll retval_2 l0_2).
+    - dump_pre_spatial.
+      apply (Hsafe_cont ATrue l0_2).
+      exact H.
+  + dump_pre_spatial. exact Hsafe_first.
+Qed.
+
+Lemma proof_of_merge_sort_derive_high_level_spec_by_low_level_spec : merge_sort_derive_high_level_spec_by_low_level_spec.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists l_high_level_spec.
+  Exists (fun l0 _ => Permutation l_high_level_spec l0 /\ incr l0).
+  split_pure_spatial.
+  + cancel (sll x_pre l_high_level_spec).
+    apply derivable1_wand_sepcon_adjoint.
+    Intros l0_2. Intros retval_2.
+    Exists l0_2. Exists retval_2.
+    repeat (split_pure_spatial || split_pures).
+    - cancel (sll retval_2 l0_2).
+    - dump_pre_spatial.
+      apply safeExec_ret in H as (? & _ & Hret).
+      sets_unfold in Hret.
+      exact (proj1 Hret).
+    - dump_pre_spatial.
+      apply safeExec_ret in H as (? & _ & Hret).
+      sets_unfold in Hret.
+      exact (proj2 Hret).
+  + dump_pre_spatial.
+    eapply safeExec_X_subset.
+    - apply Hoare_result_state.
+      apply functional_correctness_mergesort.
+    - apply safeExec_result_state.
+      exists tt. exact I.
+Qed.
+
+Lemma proof_of_split_rec_derive_low_level_spec_aux_by_low_level_spec : split_rec_derive_low_level_spec_aux_by_low_level_spec.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  apply safeExec_bind in H as (X_low_level_spec & Hsafe_first & Hsafe_cont).
+  Exists l_low_level_spec_aux. Exists l1_low_level_spec_aux. Exists l2_low_level_spec_aux.
+  Exists X_low_level_spec.
+  Exists pv_low_level_spec_aux. Exists qv_low_level_spec_aux.
+  split_pure_spatial.
+  + cancel (sll x_pre l_low_level_spec_aux).
+    cancel ((p_pre) # Ptr |-> pv_low_level_spec_aux).
+    cancel (sll pv_low_level_spec_aux l1_low_level_spec_aux).
+    cancel ((q_pre) # Ptr |-> qv_low_level_spec_aux).
+    cancel (sll qv_low_level_spec_aux l2_low_level_spec_aux).
+    apply derivable1_wand_sepcon_adjoint.
+    Intros qv'_2. Intros pv'_2. Intros s1_2. Intros s2_2.
+    Exists qv'_2. Exists pv'_2. Exists s1_2. Exists s2_2.
+    repeat (split_pure_spatial || split_pures).
+    - cancel ((p_pre) # Ptr |-> pv'_2).
+      cancel (sll pv'_2 s1_2).
+      cancel ((q_pre) # Ptr |-> qv'_2).
+      cancel (sll qv'_2 s2_2).
+    - dump_pre_spatial.
+      unfold applyf, maketuple.
+      apply (Hsafe_cont ATrue (s1_2, s2_2)).
+      exact H.
+  + dump_pre_spatial. exact Hsafe_first.
+Qed.
+
+Lemma proof_of_split_rec_derive_high_level_spec_by_low_level_spec : split_rec_derive_high_level_spec_by_low_level_spec.
+Proof.
+  LLM_pre_process ltac:(int_auto).
+  Exists l_high_level_spec. Exists (@nil Z). Exists (@nil Z).
+  Exists X_high_level_spec.
+  Exists pv_high_level_spec. Exists qv_high_level_spec.
+  split_pure_spatial.
+  + cancel (sll x_pre l_high_level_spec).
+    cancel ((p_pre) # Ptr |-> pv_high_level_spec).
+    cancel (sll pv_high_level_spec (@nil Z)).
+    cancel ((q_pre) # Ptr |-> qv_high_level_spec).
+    cancel (sll qv_high_level_spec (@nil Z)).
+    apply derivable1_wand_sepcon_adjoint.
+    Intros qv'_2. Intros pv'_2. Intros s1_2. Intros s2_2.
+    Exists qv'_2. Exists pv'_2. Exists s1_2. Exists s2_2.
+    repeat (split_pure_spatial || split_pures).
+    - cancel ((p_pre) # Ptr |-> pv'_2).
+      cancel (sll pv'_2 s1_2).
+      cancel ((q_pre) # Ptr |-> qv'_2).
+      cancel (sll qv'_2 s2_2).
+    - dump_pre_spatial. exact H0.
+  + dump_pre_spatial.
+    unfold split_rel in H.
+    unfold split_rec_rel.
+    exact H.
+Qed.

benchmarks/Algorithms/sll_merge_sort/rocq/helper_lib.v

@@ -0,0 +1,95 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From SetsClass Require Import SetsClass.
+From FP Require Import SetsFixedpoints.
+Require Import MonadLib.StateRelMonad.StateRelMonad.
+
+
+Local Open Scope Z_scope.
+Import SetsNotation.
+Local Open Scope sets.
+Import ListNotations.
+Local Open Scope string.
+Local Open Scope list.
+
+Export MonadNotation.
+Local Open Scope monad.
+
+Require Export PVbench.Algorithms.sll_merge_sort.rocq.spec_lib.
+
+Definition merge_body:
+  list Z * list Z * list Z ->
+  MONAD (CntOrBrk  (list Z * list Z * list Z) (list Z)) :=
+  fun '(l1, l2, l3) =>
+    match l1, l2 with 
+    | nil, _ => return (by_break (l3 ++ l2))
+    | _, nil => return (by_break (l3 ++ l1))
+    | x :: l1', y :: l2' =>
+        choice
+          (test' (x <= y);; return (by_continue (l1', l2, l3 ++ x :: nil)))
+          (test' (y <= x);; return (by_continue (l1, l2', l3 ++ y :: nil)))
+  end.
+
+  Definition merge_rel l l0 :=
+    repeat_break merge_body (l, l0, nil).
+
+  Definition merge_from_mid_rel l1 l2 l3 := 
+    repeat_break merge_body (l1, l2, l3).
+
+Definition reversepair : ((list Z) * (list Z)) -> MONAD ((list Z) * (list Z)) :=
+  fun '(p,q) => return (q,p).
+
+Definition split_rec_rel_f  (W : ((list Z) * (list Z) * (list Z)) ->  MONAD ((list Z) * (list Z))) 
+                        : ((list Z) * (list Z) * (list Z)) -> MONAD ((list Z) * (list Z)) :=
+  fun '(x, p, q) => match x with 
+                    | nil => return (p, q)
+                    | xh :: x' => x <- W (x', q,  xh::p) ;;
+                                  reversepair x
+                    end.
+
+Definition split_rec_rel' : ((list Z) * (list Z) * (list Z)) -> MONAD ((list Z) * (list Z)) := 
+  Lfix split_rec_rel_f.
+
+Definition split_rec_rel l1 l2 l3: MONAD ((list Z) * (list Z)) := 
+  split_rec_rel' (l1, l2, l3).
+
+Definition split_rel x :=
+  split_rec_rel' (x, nil, nil).
+
+Definition mergesortrec_f  (W :  (list Z) -> MONAD (list Z) ) 
+                      : ((list Z) -> MONAD (list Z)) :=
+  fun x => '(p1, q1) <- split_rel x ;; 
+                    match q1 with 
+                    | nil => return p1
+                    | _ :: _  =>  p2 <- W (p1) ;; 
+                                  q2 <- W (q1) ;; 
+                                  merge_rel p2 q2
+                    end.
+
+Definition mergesortrec := Lfix (mergesortrec_f).
+
+Definition mergesortrec_loc0: ((list Z) * (list Z)) -> MONAD (list Z) :=
+  fun x => match x with
+           | (p1, q1) =>
+                    match q1 with 
+                    | nil => return p1
+                    | _ :: _  =>  p2 <- mergesortrec p1 ;; 
+                                  q2 <- mergesortrec q1 ;; 
+                                  merge_rel p2 q2
+                    end
+           end.
+
+Definition mergesortrec_loc1 q1: list Z -> MONAD (list Z) :=
+  fun p2 => q2 <- mergesortrec q1 ;; 
+            merge_rel p2 q2.
+
+Definition mergesortrec_loc2 p2: list Z -> MONAD (list Z) :=
+  fun q2 => merge_rel p2 q2.
+
+Definition maketuple (x p :list Z): ((list Z) * (list Z)) := (x, p).
+Definition applyf {A B: Type} (f: A -> B) (a: A) := f a.

benchmarks/Algorithms/sll_merge_sort/rocq/solution_annotated.c

@@ -0,0 +1,205 @@
+#include "sll_def.h"
+#include "safeexec_def.h"
+
+/*@ Extern Coq
+      (Permutation : list Z -> list Z -> Prop)
+      (incr : list Z -> Prop)
+ */
+/*@ Import Coq Require Import PVbench.Algorithms.sll_merge_sort.rocq.spec_lib */
+/*@ Import Coq Require Import PVbench.Algorithms.sll_merge_sort.rocq.helper_lib */
+/*@ Extern Coq
+      (maketuple : list Z -> list Z -> ((list Z) * (list Z)))
+      (merge_rel : list Z -> list Z -> program unit (list Z))
+      (merge_from_mid_rel : list Z -> list Z -> list Z -> program unit (list Z))
+      (split_rec_rel : list Z -> list Z -> list Z -> program unit ((list Z) * (list Z)))
+      (split_rel : list Z -> program unit ((list Z) * (list Z)))
+      (reversepair : ((list Z) * (list Z)) -> program unit ((list Z) * (list Z)))
+      (mergesortrec : list Z -> program unit (list Z))
+      (mergesortrec_loc1 : list Z -> list Z -> program unit (list Z))
+      (mergesortrec_loc2 : list Z -> list Z -> program unit (list Z))
+      (mergesortrec_loc0 : ((list Z) * (list Z)) -> program unit (list Z))
+ */
+
+struct list *merge(struct list *x, struct list *y)
+/*@ With s1 s2 X
+    Require safeExec(ATrue, merge_rel(s1, s2), X) && sll(x, s1) * sll(y, s2)
+    Ensure exists s3, safeExec(ATrue, return(s3), X) && sll(__return, s3)
+*/
+{
+  struct list **t, *ret;
+  t = &ret;
+  /*@ Inv Assert
+    exists l1 l2 l3,
+      safeExec(ATrue, merge_from_mid_rel(l1, l2, l3), X) && 
+      sll(x, l1) * sll(y, l2) *
+      has_ptr_permission(t) * sllbseg(&ret, t, l3)
+  */
+  while (1)
+  {
+    if (x == (void *)0) {
+      *t = y;
+      break;
+    }
+    if (y == (void *)0) {
+      *t = x;
+      break;
+    }
+    /*@ Assert
+      exists l1 l2 l3 l1_new l2_new xdata ydata xnext ynext,
+        safeExec(ATrue, merge_from_mid_rel(l1, l2, l3), X) &&
+        x != 0 && y != 0 &&
+        l1 == cons(xdata, l1_new) &&
+        l2 == cons(ydata, l2_new) &&
+        store(&(x->data), xdata) * store(&(y->data), ydata) *
+        store(&(x->next), xnext) * store(&(y->next), ynext) *
+        sll(xnext, l1_new) * sll(ynext, l2_new) *
+        has_ptr_permission(t) * sllbseg(&ret, t, l3)
+    */
+    if (x->data < y->data) {
+      *t = x;
+      t = &(x->next);
+      x = x->next;
+    } else {
+      *t = y;
+      t = &(y->next);
+      y = y->next;
+    }
+  }
+  /*@ Assert
+      exists s3,
+        safeExec(ATrue, return(s3), X) &&
+        store(&x, struct list*, x) *
+        store(&y, struct list*, y) *
+        store(&t, struct list**, t) *
+        sll(ret, s3)
+  */
+  return ret;
+}
+
+void split_rec(struct list * x, struct list * * p, struct list * * q)
+  /*@ high_level_spec <= low_level_spec
+      With l X pv qv
+      Require safeExec(ATrue, split_rel(l), X) &&
+              store(p, pv) * store(q, qv) *
+              sll(x, l) * sll(pv, nil) * sll(qv, nil)
+      Ensure exists s1 s2 pv' qv',
+              safeExec(ATrue, return(maketuple(s1, s2)), X) &&
+              store(p, pv') * store(q, qv') * 
+              sll(pv', s1) * sll(qv', s2)
+   */
+;
+
+void split_rec(struct list * x, struct list * * p, struct list * * q)
+  /*@ low_level_spec_aux <= low_level_spec
+      With {B} l l1 l2 (c : ((list Z) * (list Z)) -> program unit B) X pv qv
+      Require safeExec(ATrue, bind(split_rec_rel(l, l1, l2), c), X) &&
+              store(p, pv) * store(q, qv) *
+              sll(x, l) * sll(pv, l1) * sll(qv, l2)
+      Ensure exists s1 s2 pv' qv',
+              safeExec(ATrue, applyf(c, maketuple(s1,s2)), X) &&
+              store(p, pv') * store(q, qv') *
+              sll(pv', s1) * sll(qv', s2)
+   */
+;
+
+void split_rec(struct list * x, struct list * * p, struct list * * q)
+  /*@ low_level_spec
+      With l l1 l2 X pv qv
+      Require safeExec(ATrue, split_rec_rel(l, l1, l2), X) &&
+              store(p, pv) * store(q, qv) *
+              sll(x, l) * sll(pv, l1) * sll(qv, l2)
+      Ensure exists s1 s2 pv' qv',
+              safeExec(ATrue, return(maketuple(s1, s2)), X) &&
+              store(p, pv') * store(q, qv') *
+              sll(pv', s1) * sll(qv', s2)
+  */
+{
+  if (x == (void *)0) {
+    return;
+  }
+  /*@ Assert
+      exists l_new x_data x_next,
+        x == x@pre && p == p@pre && q == q@pre &&
+        x != 0 &&
+        safeExec(ATrue, split_rec_rel(l, l1, l2), X) &&
+        l == cons(x_data, l_new) &&
+        store(&(x->data), x_data) * store(&(x->next), x_next) *
+        store(p, pv) * store(q, qv) *
+        sll(x_next, l_new) * sll(pv, l1) * sll(qv, l2)
+  */
+  struct list * t;
+  t = x -> next;
+  x -> next = * p;
+  * p = x;
+  /*@ Assert
+      exists l_new x_data,
+      x == x@pre && p == p@pre && q == q@pre &&
+        x != 0 &&
+        safeExec(ATrue, bind(split_rec_rel(l_new, l2, cons(x_data, l1)), reversepair), X) &&
+        l == cons(x_data, l_new) &&
+      store(p, x) * store(q, qv) *
+      sll(x, cons(x_data, l1)) * sll(t, l_new) * sll(qv, l2)
+  */
+  split_rec(t, q, p) /*@ where(low_level_spec_aux) l1 = l2, c = reversepair,  X = X; B = (list Z) * (list Z) */; 
+}
+
+struct list * merge_sort(struct list * x)
+  /*@ high_level_spec <= low_level_spec
+      With l
+      Require sll(x, l)
+      Ensure exists l0,
+              Permutation(l, l0) && incr(l0) &&
+              sll(__return, l0)
+   */
+;
+
+struct list * merge_sort(struct list * x)
+  /*@ low_level_spec_aux <= low_level_spec
+      With {B} l (c: list Z -> program unit B) X
+      Require safeExec(ATrue, bind(mergesortrec(l), c), X) && sll(x, l)
+      Ensure exists l0,
+              safeExec(ATrue, applyf(c, l0), X) && 
+              sll(__return, l0)
+   */
+;
+
+struct list * merge_sort(struct list * x)
+  /*@ low_level_spec
+      With l X
+      Require safeExec(ATrue, mergesortrec(l), X) && sll(x, l)
+      Ensure exists l0,
+              safeExec(ATrue, return(l0), X) &&
+              sll(__return, l0)
+  */
+{
+  struct list * p, * q;
+  p = (void *)0;
+  /*@ Assert
+    x == x@pre && p == 0 && has_ptr_permission(&q) && safeExec(ATrue, mergesortrec(l), X) && sll(p, nil) * sll(x, l)
+  */
+  q = (void *)0;
+  /*@ Assert
+    x == x@pre && p == 0 && q == 0 && safeExec(ATrue, mergesortrec(l), X) && sll(p, nil) * sll(q, nil) * sll(x, l)
+  */
+ /*@ Assert
+    x == x@pre && p == 0 && q == 0 && safeExec(ATrue, bind(split_rel(l), mergesortrec_loc0), X) && sll(p, nil) * sll(q, nil) * sll(x, l)
+  */
+  split_rec(x, &p, &q) /*@ where(low_level_spec_aux) X = X, c = mergesortrec_loc0; B = (list Z) */;
+  if (q == (void *)0) {
+    return p;
+  }
+  /*@ Assert 
+    exists l1 l2, 
+    x == x@pre && q != 0 && 
+    safeExec(ATrue, bind(mergesortrec(l1), mergesortrec_loc1(l2)), X) && sll(p, l1) * sll(q, l2)  */
+  p = merge_sort(p) /*@ where(low_level_spec_aux) X = X; B = (list Z) */;
+  /*@ Assert 
+      exists l1 l2, 
+      x == x@pre && q != 0 && 
+      safeExec(ATrue, bind(mergesortrec(l2), mergesortrec_loc2(l1)), X) && sll(p, l1) * sll(q, l2)  */
+  q = merge_sort(q) /*@ where(low_level_spec_aux) X = X; B = (list Z) */;
+  /*@ Assert 
+      exists l1 l2, x == x@pre && 
+      safeExec(ATrue, merge_rel(l1, l2), X) && sll(p, l1) * sll(q, l2) */
+  return merge(p, q) /*@ where X = X */;
+}

benchmarks/Algorithms/sll_merge_sort/rocq/solution_spec.c

@@ -0,0 +1,66 @@
+#include "sll_def.h"
+
+/*@ Extern Coq
+      (Permutation : list Z -> list Z -> Prop)
+      (incr : list Z -> Prop)
+ */
+/*@ Import Coq Require Import PVbench.Algorithms.sll_merge_sort.rocq.spec_lib */
+
+struct list *merge(struct list *x, struct list *y)
+{
+  struct list **t, *ret;
+  t = &ret;
+  while (1)
+  {
+    if (x == (void *)0) {
+      *t = y;
+      break;
+    }
+    if (y == (void *)0) {
+      *t = x;
+      break;
+    }
+    if (x->data < y->data) {
+      *t = x;
+      t = &(x->next);
+      x = x->next;
+    } else {
+      *t = y;
+      t = &(y->next);
+      y = y->next;
+    }
+  }
+  return ret;
+}
+
+void split_rec(struct list * x, struct list * * p, struct list * * q)
+{
+  if (x == (void *)0) {
+    return;
+  }
+  struct list * t;
+  t = x -> next;
+  x -> next = * p;
+  * p = x;
+  split_rec(t, q, p); 
+}
+
+struct list * merge_sort(struct list * x)
+/*@ With l
+    Require sll(x, l)
+    Ensure exists l0,
+      Permutation(l, l0) && incr(l0) &&
+      sll(__return, l0)
+ */
+{
+  struct list * p, * q;
+  p = (void *)0;
+  q = (void *)0;
+  split_rec(x, &p, &q);
+  if (q == (void *)0) {
+    return p;
+  }
+  p = merge_sort(p);
+  q = merge_sort(q);
+  return merge(p, q);
+}

benchmarks/Algorithms/sll_merge_sort/rocq/spec_lib.v

@@ -0,0 +1,18 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Lists.List.
+
+Local Open Scope Z_scope.
+Import ListNotations.
+Local Open Scope list.
+
+Fixpoint incr_aux (l: list Z) (x: Z): Prop :=
+  match l with
+  | nil => True
+  | y :: l0 => x <= y /\ incr_aux l0 y
+  end.
+
+Definition incr (l: list Z): Prop :=
+  match l with
+  | nil => True
+  | x :: l0 => incr_aux l0 x
+  end.

benchmarks/Algorithms/sll_merge_sort/solution.c

@@ -0,0 +1,54 @@
+#include "sll_def.h"
+
+struct list *merge(struct list *x, struct list *y)
+{
+  struct list **t, *ret;
+  t = &ret;
+  while (1)
+  {
+    if (x == (void *)0) {
+      *t = y;
+      break;
+    }
+    if (y == (void *)0) {
+      *t = x;
+      break;
+    }
+    if (x->data < y->data) {
+      *t = x;
+      t = &(x->next);
+      x = x->next;
+    } else {
+      *t = y;
+      t = &(y->next);
+      y = y->next;
+    }
+  }
+  return ret;
+}
+
+void split_rec(struct list * x, struct list * * p, struct list * * q)
+{
+  if (x == (void *)0) {
+    return;
+  }
+  struct list * t;
+  t = x -> next;
+  x -> next = * p;
+  * p = x;
+  split_rec(t, q, p); 
+}
+
+struct list * merge_sort(struct list * x)
+{
+  struct list * p, * q;
+  p = (void *)0;
+  q = (void *)0;
+  split_rec(x, &p, &q);
+  if (q == (void *)0) {
+    return p;
+  }
+  p = merge_sort(p);
+  q = merge_sort(q);
+  return merge(p, q);
+}

benchmarks/Data_structures/dll_queue/manifest.json

@@ -0,0 +1,19 @@
+{
+  "id": "dll_queue",
+  "source": {
+    "dataset": "classical_data_structure",
+    "problem_id": "dll_queue",
+    "title": "Queue on a Doubly Linked List",
+    "tags": [
+      "data structures",
+      "queue",
+      "linked list"
+    ]
+  },
+  "stratification": {
+    "band": "unclassified",
+    "output_mode": "CONSTRUCT",
+    "interactive": false,
+    "multi_test": false
+  }
+}

benchmarks/Data_structures/dll_queue/problem.md

@@ -0,0 +1,15 @@
+# Queue on a Doubly Linked List
+
+## Description
+
+Maintain a first-in first-out queue of integers stored in a doubly linked list with head and tail pointers, supporting insertion at the back and removal from the front.
+
+## Input
+
+- `enqueue` receives a queue `q` and an integer `x`.
+- `dequeue` receives a non-empty queue `q`.
+
+## Output
+
+- `enqueue` appends `x` at the back of `q`.
+- `dequeue` removes the element at the front of `q` and returns it.

benchmarks/Data_structures/dll_queue/rocq/dll_queue_store.strategies

@@ -0,0 +1,24 @@
+//test curent rules
+//max rule id:30
+
+#include "dll_queue_store_def.h"
+
+
+
+
+id : 0
+priority : core(2)
+left : store_queue(?p, ?l0) at 0
+right : store_queue(p, ?l1) at 1
+action : left_erase(0);
+         right_erase(1);
+         right_add(l0 == l1);
+
+id : 1
+priority : core(2)
+left : dllseg(?p, 0, ?q, ?r, ?l0) at 0
+right : dllseg(p, 0, q, r, ?l1) at 1
+action : left_erase(0);
+         right_erase(1);
+         right_add(l0 == l1);
+

benchmarks/Data_structures/dll_queue/rocq/dll_queue_store_def.h

@@ -0,0 +1,16 @@
+struct list {
+  int data;
+  struct list *next;
+  struct list *prev;
+};
+
+struct queue {
+  struct list * head;
+  struct list * tail;
+};
+
+/*@ Import Coq Require Import PVbench.Data_structures.dll_queue.rocq.spec_lib */
+
+/*@ Extern Coq (store_queue : Z -> list Z -> Assertion)
+               (dllseg: Z -> Z -> Z -> Z -> list Z -> Assertion)
+ */

benchmarks/Data_structures/dll_queue/rocq/groundtruth/dll_queue_goal.v

@@ -0,0 +1,453 @@
+Require Import Coq.ZArith.ZArith.
+Require Import Coq.Bool.Bool.
+Require Import Coq.Strings.String.
+Require Import Coq.Strings.Ascii.
+Require Import Coq.Lists.List.
+Require Import Coq.Classes.RelationClasses.
+Require Import Coq.Classes.Morphisms.
+Require Import Coq.micromega.Psatz.
+Require Import Coq.Sorting.Permutation.
+From AUXLib Require Import int_auto Axioms Feq Idents ListLib VMap.
+Require Import SetsClass.SetsClass. Import SetsNotation.
+From SimpleC.SL Require Import Mem SeparationLogic.
+Require Import Logic.LogicGenerator.demo932.Interface.
+Local Open Scope Z_scope.
+Local Open Scope sets.
+Local Open Scope string_scope.
+Local Open Scope list.
+Import naive_C_Rules.
+Require Import PVbench.Data_structures.dll_queue.rocq.spec_lib.
+Local Open Scope sac.
+From PVbench.Data_structures.dll_queue.rocq.groundtruth Require Import dll_queue_store_strategy_goal.
+From PVbench.Data_structures.dll_queue.rocq.groundtruth Require Import dll_queue_store_strategy_proof.
+
+(*----- Function enqueue -----*)
+
+Definition enqueue_safety_wit_1 := 
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (retval: Z) (PreH1 : (retval <> 0)) ,
+  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> retval)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition enqueue_safety_wit_2 := 
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (retval: Z) (PreH1 : (qhead = 0)) (PreH2 : (retval <> 0)) ,
+  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> retval)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> retval)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> retval)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition enqueue_safety_wit_3 := 
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (retval: Z) (PreH1 : (qhead = 0)) (PreH2 : (retval <> 0)) ,
+  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> retval)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> retval)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> retval)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition enqueue_safety_wit_4 := 
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (l0: (@list Z)) (qtailv: Z) (qtail: Z) (qhead: Z) (qtailnext: Z) (qtailprev: Z) (p: Z) (PreH1 : (p <> 0)) (PreH2 : (qtail <> 0)) (PreH3 : (qhead <> 0)) (PreH4 : (l = (app (l0) ((cons (qtailv) ((@nil Z))))))) (PreH5 : (qtailnext = 0)) ,
+  ((( &( "x" ) )) # Int  |-> x_pre)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  (dllseg qhead qtail 0 qtailprev l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> p)
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((qtail)  # "list" ->ₛ "next")) # Ptr  |-> p)
+  **  ((&((qtail)  # "list" ->ₛ "prev")) # Ptr  |-> qtailprev)
+  **  ((&((qtail)  # "list" ->ₛ "data")) # Int  |-> qtailv)
+  **  ((&((p)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((p)  # "list" ->ₛ "prev")) # Ptr  |-> qtail)
+  **  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition enqueue_entail_wit_1 := 
+(
+forall (q_pre: Z) (l: (@list Z)) ,
+  (store_queue q_pre l )
+|--
+  EX (qhead: Z)  (qtail: Z) ,
+  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+) \/
+(
+forall (q_pre: Z) (l: (@list Z)) ,
+  (store_queue q_pre l )
+|--
+  EX (qhead: Z)  (qtail: Z) ,
+  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+).
+
+Definition enqueue_entail_wit_2 := 
+(
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (qhead_2: Z) (qtail_2: Z) (retval: Z) (PreH1 : (qhead_2 <> 0)) (PreH2 : (retval <> 0)) ,
+  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+  **  (dllseg qhead_2 0 0 qtail_2 l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead_2)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail_2)
+|--
+  EX (qtailprev: Z)  (qtailnext: Z)  (l0: (@list Z))  (qtailv: Z)  (qhead: Z)  (qtail: Z) ,
+  “ (retval <> 0) ” 
+  &&  “ (qtail <> 0) ” 
+  &&  “ (qhead <> 0) ” 
+  &&  “ (l = (app (l0) ((cons (qtailv) ((@nil Z)))))) ” 
+  &&  “ (qtailnext = 0) ”
+  &&  (dllseg qhead qtail 0 qtailprev l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((qtail)  # "list" ->ₛ "next")) # Ptr  |-> qtailnext)
+  **  ((&((qtail)  # "list" ->ₛ "prev")) # Ptr  |-> qtailprev)
+  **  ((&((qtail)  # "list" ->ₛ "data")) # Int  |-> qtailv)
+  **  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+) \/
+(
+forall (l: (@list Z)) (qhead_2: Z) (qtail_2: Z) (retval: Z) (PreH1 : (qhead_2 <> 0)) (PreH2 : (retval <> 0)) ,
+  (dllseg qhead_2 0 0 qtail_2 l )
+|--
+  EX (qtailprev: Z)  (l0: (@list Z))  (qtailv: Z) ,
+  “ (retval <> 0) ” 
+  &&  “ (qtail_2 <> 0) ” 
+  &&  “ (qhead_2 <> 0) ” 
+  &&  “ (l = (app (l0) ((cons (qtailv) ((@nil Z)))))) ”
+  &&  (dllseg qhead_2 qtail_2 0 qtailprev l0 )
+  **  ((&((qtail_2)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((qtail_2)  # "list" ->ₛ "prev")) # Ptr  |-> qtailprev)
+  **  ((&((qtail_2)  # "list" ->ₛ "data")) # Int  |-> qtailv)
+).
+
+Definition enqueue_return_wit_1 := 
+(
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (retval: Z) (PreH1 : (qhead = 0)) (PreH2 : (retval <> 0)) ,
+  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+  **  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> retval)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> retval)
+|--
+  (store_queue q_pre (app (l) ((cons (x_pre) ((@nil Z))))) )
+) \/
+(
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (retval: Z) (PreH1 : (x_pre <= INT_MAX)) (PreH2 : (x_pre >= INT_MIN)) (PreH3 : (qhead = 0)) (PreH4 : (retval <> 0)) ,
+  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+  **  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> retval)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> retval)
+|--
+  (store_queue q_pre (app (l) ((cons (x_pre) ((@nil Z))))) )
+).
+
+Definition enqueue_return_wit_1_split_goal_spatial := 
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (retval: Z) (PreH1 : (x_pre <= INT_MAX)) (PreH2 : (x_pre >= INT_MIN)) (PreH3 : (qhead = 0)) (PreH4 : (retval <> 0)) ,
+  ((&((retval)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((retval)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+  **  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> retval)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> retval)
+|--
+  (store_queue q_pre (app (l) ((cons (x_pre) ((@nil Z))))) )
+.
+
+Definition enqueue_return_wit_2 := 
+(
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (l0: (@list Z)) (qtailv: Z) (qtail: Z) (qhead: Z) (qtailnext: Z) (qtailprev: Z) (p: Z) (PreH1 : (p <> 0)) (PreH2 : (qtail <> 0)) (PreH3 : (qhead <> 0)) (PreH4 : (l = (app (l0) ((cons (qtailv) ((@nil Z))))))) (PreH5 : (qtailnext = 0)) ,
+  (dllseg qhead qtail 0 qtailprev l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> p)
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((qtail)  # "list" ->ₛ "next")) # Ptr  |-> p)
+  **  ((&((qtail)  # "list" ->ₛ "prev")) # Ptr  |-> qtailprev)
+  **  ((&((qtail)  # "list" ->ₛ "data")) # Int  |-> qtailv)
+  **  ((&((p)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((p)  # "list" ->ₛ "prev")) # Ptr  |-> qtail)
+  **  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+|--
+  (store_queue q_pre (app (l) ((cons (x_pre) ((@nil Z))))) )
+) \/
+(
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (l0: (@list Z)) (qtailv: Z) (qtail: Z) (qhead: Z) (qtailnext: Z) (qtailprev: Z) (p: Z) (PreH1 : (x_pre <= INT_MAX)) (PreH2 : (qtailv <= INT_MAX)) (PreH3 : (x_pre >= INT_MIN)) (PreH4 : (qtailv >= INT_MIN)) (PreH5 : (p <> 0)) (PreH6 : (qtail <> 0)) (PreH7 : (qhead <> 0)) (PreH8 : (l = (app (l0) ((cons (qtailv) ((@nil Z))))))) (PreH9 : (qtailnext = 0)) ,
+  (dllseg qhead qtail 0 qtailprev l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> p)
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((qtail)  # "list" ->ₛ "next")) # Ptr  |-> p)
+  **  ((&((qtail)  # "list" ->ₛ "prev")) # Ptr  |-> qtailprev)
+  **  ((&((qtail)  # "list" ->ₛ "data")) # Int  |-> qtailv)
+  **  ((&((p)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((p)  # "list" ->ₛ "prev")) # Ptr  |-> qtail)
+  **  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+|--
+  (store_queue q_pre (app (l) ((cons (x_pre) ((@nil Z))))) )
+).
+
+Definition enqueue_return_wit_2_split_goal_spatial := 
+forall (x_pre: Z) (q_pre: Z) (l: (@list Z)) (l0: (@list Z)) (qtailv: Z) (qtail: Z) (qhead: Z) (qtailnext: Z) (qtailprev: Z) (p: Z) (PreH1 : (x_pre <= INT_MAX)) (PreH2 : (qtailv <= INT_MAX)) (PreH3 : (x_pre >= INT_MIN)) (PreH4 : (qtailv >= INT_MIN)) (PreH5 : (p <> 0)) (PreH6 : (qtail <> 0)) (PreH7 : (qhead <> 0)) (PreH8 : (l = (app (l0) ((cons (qtailv) ((@nil Z))))))) (PreH9 : (qtailnext = 0)) ,
+  (dllseg qhead qtail 0 qtailprev l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> p)
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((qtail)  # "list" ->ₛ "next")) # Ptr  |-> p)
+  **  ((&((qtail)  # "list" ->ₛ "prev")) # Ptr  |-> qtailprev)
+  **  ((&((qtail)  # "list" ->ₛ "data")) # Int  |-> qtailv)
+  **  ((&((p)  # "list" ->ₛ "next")) # Ptr  |-> 0)
+  **  ((&((p)  # "list" ->ₛ "prev")) # Ptr  |-> qtail)
+  **  ((&((p)  # "list" ->ₛ "data")) # Int  |-> x_pre)
+|--
+  (store_queue q_pre (app (l) ((cons (x_pre) ((@nil Z))))) )
+.
+
+Definition enqueue_partial_solve_wit_1 := 
+forall (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) ,
+  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  (dllseg qhead 0 0 qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+.
+
+(*----- Function dequeue -----*)
+
+Definition dequeue_safety_wit_1 := 
+forall (q_pre: Z) (l: (@list Z)) (x: Z) (qhead: Z) (qtail: Z) (qheadnext: Z) (PreH1 : (qhead <> 0)) ,
+  ((( &( "x0" ) )) # Int  |-> x)
+  **  ((( &( "p" ) )) # Ptr  |-> qhead)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition dequeue_safety_wit_2 := 
+forall (q_pre: Z) (l: (@list Z)) (x: Z) (qhead: Z) (qtail: Z) (qheadnext: Z) (PreH1 : (qheadnext = 0)) (PreH2 : (qhead <> 0)) ,
+  ((( &( "x0" ) )) # Int  |-> x)
+  **  ((( &( "p" ) )) # Ptr  |-> qhead)
+  **  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition dequeue_safety_wit_3 := 
+forall (q_pre: Z) (l: (@list Z)) (x: Z) (qhead: Z) (qtail: Z) (headv: Z) (qheadnext: Z) (l0: (@list Z)) (p: Z) (PreH1 : (qhead <> 0)) (PreH2 : (l = (cons (headv) (l0)))) ,
+  ((( &( "q" ) )) # Ptr  |-> q_pre)
+  **  ((( &( "x0" ) )) # Int  |-> x)
+  **  ((( &( "p" ) )) # Ptr  |-> p)
+  **  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> p)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> headv)
+  **  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead qtail l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  “ (0 <= INT_MAX) ” 
+  &&  “ ((INT_MIN) <= 0) ”
+.
+
+Definition dequeue_entail_wit_1 := 
+(
+forall (q_pre: Z) (l: (@list Z)) (x: Z) ,
+  (store_queue q_pre (cons (x) (l)) )
+|--
+  EX (qtail: Z)  (qheadnext: Z)  (qhead: Z) ,
+  “ (qhead <> 0) ”
+  &&  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+) \/
+(
+forall (q_pre: Z) (l: (@list Z)) (x: Z) ,
+  (store_queue q_pre (cons (x) (l)) )
+|--
+  EX (qtail: Z)  (qheadnext: Z)  (qhead: Z) ,
+  “ (qhead <> 0) ”
+  &&  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+).
+
+Definition dequeue_entail_wit_2 := 
+(
+forall (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail_2: Z) (qheadnext_2: Z) (PreH1 : (qheadnext_2 <> 0)) (PreH2 : (qhead <> 0)) ,
+  (dllseg qheadnext_2 0 qhead qtail_2 l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext_2)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail_2)
+|--
+  EX (qtail: Z)  (qheadnext: Z)  (headv: Z)  (l0: (@list Z))  (qhead_2: Z) ,
+  “ (qhead_2 <> 0) ” 
+  &&  “ (l = (cons (headv) (l0))) ”
+  &&  ((&((qhead_2)  # "list" ->ₛ "prev")) # Ptr  |-> qhead)
+  **  ((&((qhead_2)  # "list" ->ₛ "data")) # Int  |-> headv)
+  **  ((&((qhead_2)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead_2 qtail l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead_2)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+) \/
+(
+forall (l: (@list Z)) (qhead: Z) (qtail_2: Z) (qheadnext_2: Z) (PreH1 : (qheadnext_2 <> 0)) (PreH2 : (qhead <> 0)) ,
+  (dllseg qheadnext_2 0 qhead qtail_2 l )
+|--
+  EX (qheadnext: Z)  (headv: Z)  (l0: (@list Z)) ,
+  “ (qheadnext_2 <> 0) ” 
+  &&  “ (l = (cons (headv) (l0))) ”
+  &&  ((&((qheadnext_2)  # "list" ->ₛ "prev")) # Ptr  |-> qhead)
+  **  ((&((qheadnext_2)  # "list" ->ₛ "data")) # Int  |-> headv)
+  **  ((&((qheadnext_2)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qheadnext_2 qtail_2 l0 )
+).
+
+Definition dequeue_return_wit_1 := 
+(
+forall (q_pre: Z) (l: (@list Z)) (x: Z) (qhead: Z) (qtail: Z) (qheadnext: Z) (PreH1 : (qheadnext = 0)) (PreH2 : (qhead <> 0)) ,
+  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> 0)
+|--
+  “ (x = x) ”
+  &&  (store_queue q_pre l )
+) \/
+(
+forall (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (qheadnext: Z) (PreH1 : (qheadnext = 0)) (PreH2 : (qhead <> 0)) ,
+  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> 0)
+|--
+  (store_queue q_pre l )
+).
+
+Definition dequeue_return_wit_1_split_goal_spatial := 
+forall (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (qheadnext: Z) (PreH1 : (qheadnext = 0)) (PreH2 : (qhead <> 0)) ,
+  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> 0)
+|--
+  (store_queue q_pre l )
+.
+
+Definition dequeue_return_wit_2 := 
+(
+forall (q_pre: Z) (l: (@list Z)) (x: Z) (qhead: Z) (qtail: Z) (headv: Z) (qheadnext: Z) (l0: (@list Z)) (PreH1 : (qhead <> 0)) (PreH2 : (l = (cons (headv) (l0)))) ,
+  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> headv)
+  **  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead qtail l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  “ (x = x) ”
+  &&  (store_queue q_pre l )
+) \/
+(
+forall (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (headv: Z) (qheadnext: Z) (l0: (@list Z)) (PreH1 : (headv <= INT_MAX)) (PreH2 : (headv >= INT_MIN)) (PreH3 : (qhead <> 0)) (PreH4 : (l = (cons (headv) (l0)))) ,
+  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> headv)
+  **  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead qtail l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  (store_queue q_pre l )
+).
+
+Definition dequeue_return_wit_2_split_goal_spatial := 
+forall (q_pre: Z) (l: (@list Z)) (qhead: Z) (qtail: Z) (headv: Z) (qheadnext: Z) (l0: (@list Z)) (PreH1 : (headv <= INT_MAX)) (PreH2 : (headv >= INT_MIN)) (PreH3 : (qhead <> 0)) (PreH4 : (l = (cons (headv) (l0)))) ,
+  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> headv)
+  **  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead qtail l0 )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qhead)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  (store_queue q_pre l )
+.
+
+Definition dequeue_partial_solve_wit_1 := 
+forall (q_pre: Z) (l: (@list Z)) (x: Z) (qhead: Z) (qtail: Z) (qheadnext: Z) (PreH1 : (qhead <> 0)) ,
+  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+|--
+  “ (qhead <> 0) ”
+  &&  ((&((qhead)  # "list" ->ₛ "next")) # Ptr  |-> qheadnext)
+  **  ((&((qhead)  # "list" ->ₛ "prev")) # Ptr  |-> 0)
+  **  ((&((qhead)  # "list" ->ₛ "data")) # Int  |-> x)
+  **  (dllseg qheadnext 0 qhead qtail l )
+  **  ((&((q_pre)  # "queue" ->ₛ "head")) # Ptr  |-> qheadnext)
+  **  ((&((q_pre)  # "queue" ->ₛ "tail")) # Ptr  |-> qtail)
+.
+
+Module Type VC_Correct.
+
+Include dll_queue_store_Strategy_Correct.
+
+Axiom proof_of_enqueue_safety_wit_1 : enqueue_safety_wit_1.
+Axiom proof_of_enqueue_safety_wit_2 : enqueue_safety_wit_2.
+Axiom proof_of_enqueue_safety_wit_3 : enqueue_safety_wit_3.
+Axiom proof_of_enqueue_safety_wit_4 : enqueue_safety_wit_4.
+Axiom proof_of_enqueue_entail_wit_1 : enqueue_entail_wit_1.
+Axiom proof_of_enqueue_entail_wit_2 : enqueue_entail_wit_2.
+Axiom proof_of_enqueue_return_wit_1 : enqueue_return_wit_1.
+Axiom proof_of_enqueue_return_wit_2 : enqueue_return_wit_2.
+Axiom proof_of_enqueue_partial_solve_wit_1 : enqueue_partial_solve_wit_1.
+Axiom proof_of_dequeue_safety_wit_1 : dequeue_safety_wit_1.
+Axiom proof_of_dequeue_safety_wit_2 : dequeue_safety_wit_2.
+Axiom proof_of_dequeue_safety_wit_3 : dequeue_safety_wit_3.
+Axiom proof_of_dequeue_entail_wit_1 : dequeue_entail_wit_1.
+Axiom proof_of_dequeue_entail_wit_2 : dequeue_entail_wit_2.
+Axiom proof_of_dequeue_return_wit_1 : dequeue_return_wit_1.
+Axiom proof_of_dequeue_return_wit_2 : dequeue_return_wit_2.
+Axiom proof_of_dequeue_partial_solve_wit_1 : dequeue_partial_solve_wit_1.
+
+End VC_Correct.

benchmarks/Data_structures/dll_queue/rocq/groundtruth/dll_queue_goal_check.v

@@ -0,0 +1,7 @@
+From PVbench.Data_structures.dll_queue.rocq.groundtruth Require Import dll_queue_goal dll_queue_proof_auto dll_queue_proof_manual.
+
+Module VC_Correctness : VC_Correct.
+  Include dll_queue_store_strategy_proof.
+  Include dll_queue_proof_auto.
+  Include dll_queue_proof_manual.
+End VC_Correctness.